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

// Created by: Peter KURNEV
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

#include <BOPAlgo_Tools.ixx>
#include <BOPDS_DS.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPCol_IndexedMapOfInteger.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
	2	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	3	//
	4	// The content of this file is subject to the Open CASCADE Technology Public
	5	// License Version 6.5 (the "License"). You may not use the content of this file
	6	// except in compliance with the License. Please obtain a copy of the License
	7	// at http://www.opencascade.org and read it completely before using this file.
	8	//
	9	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	10	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	11	//
	12	// The Original Code and all software distributed under the License is
	13	// distributed on an "AS IS" basis, without warranty of any kind, and the
	14	// Initial Developer hereby disclaims all such warranties, including without
	15	// limitation, any warranties of merchantability, fitness for a particular
	16	// purpose or non-infringement. Please see the License for the specific terms
	17	// and conditions governing the rights and limitations under the License.
	18
	19	#include <BOPAlgo_Tools.ixx>
5a77460e	20	#include <BOPDS_DS.hxx>
4e57c75e	21	#include <BOPDS_MapOfPaveBlock.hxx>
	22	#include <BOPDS_IndexedMapOfPaveBlock.hxx>
	23	#include <BOPDS_CommonBlock.hxx>
	24	#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
	25	#include <BOPCol_IndexedMapOfInteger.hxx>
	26
	27	//=======================================================================
	28	//function : MakeBlocksCnx
	29	//purpose :
	30	//=======================================================================
	31	void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
	32	BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
	33	Handle(NCollection_BaseAllocator)& aAllocator)
	34	{
	35	Standard_Integer aNbV, nV, aNbVS, nVP, nVx, aNbVP, aNbEC, k, i, j;
	36	BOPCol_ListIteratorOfListOfInteger aItLI;
	37	//
	38	BOPCol_MapOfInteger aMVS(100, aAllocator);
	39	BOPCol_IndexedMapOfInteger aMEC(100, aAllocator);
	40	BOPCol_IndexedMapOfInteger aMVP(100, aAllocator);
	41	BOPCol_IndexedMapOfInteger aMVAdd(100, aAllocator);
	42	//
	43	aNbV=aMILI.Extent();
	44	//
	45	for (k=0,i=1; i<=aNbV; ++i) {
	46	aNbVS=aMVS.Extent();
	47	if (aNbVS==aNbV) {
	48	break;
	49	}
	50	//
	51	nV = aMILI.FindKey(i);
	52	if (aMVS.Contains(nV)){
	53	continue;
	54	}
	55	aMVS.Add(nV);
	56	//
	57	aMEC.Clear();
	58	aMVP.Clear();
	59	aMVAdd.Clear();
	60	//
	61	aMVP.Add(nV);
302f96fb	62	for(;;) {
4e57c75e	63	aNbVP=aMVP.Extent();
	64	for (j=1; j<=aNbVP; ++j) {
	65	nVP=aMVP(j);
	66	const BOPCol_ListOfInteger& aLV=aMILI.FindFromKey(nVP);
	67	aItLI.Initialize(aLV);
	68	for (; aItLI.More(); aItLI.Next()) {
	69	nVx=aItLI.Value();
	70	if (aMEC.Contains(nVx)) {
	71	continue;
	72	}
	73	//
	74	aMVS.Add(nVx);
	75	aMEC.Add(nVx);
	76	aMVAdd.Add(nVx);
	77	}
	78	}
	79	//
	80	aNbVP=aMVAdd.Extent();
	81	if (!aNbVP) {
	82	break; // from while(1)
	83	}
	84	//
	85	aMVP.Clear();
	86	for (j=1; j<=aNbVP; ++j) {
	87	aMVP.Add(aMVAdd(j));
	88	}
	89	aMVAdd.Clear();
	90	}//while(1) {
	91	//
	92	BOPCol_ListOfInteger aLIx(aAllocator);
	93	//
	94	aNbEC = aMEC.Extent();
	95	for (j=1; j<=aNbEC; ++j) {
	96	nVx=aMEC(j);
	97	aLIx.Append(nVx);
	98	}
	99	//
	100	aMBlocks.Bind(k, aLIx);
	101	++k;
	102	}//for (k=0,i=1; i<=aNbV; ++i)
	103	aMVAdd.Clear();
	104	aMVP.Clear();
	105	aMEC.Clear();
	106	aMVS.Clear();
	107	}
	108	//=======================================================================
	109	//function : FillMap
	110	//purpose :
	111	//=======================================================================
	112	void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
	113	const Standard_Integer n2,
	114	BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
	115	Handle(NCollection_BaseAllocator)& aAllocator)
	116	{
	117	if (aMILI.Contains(n1)) {
	118	BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n1);
	119	aLI.Append(n2);
	120	}
	121	else {
	122	BOPCol_ListOfInteger aLI(aAllocator);
	123	aLI.Append(n2);
	124	aMILI.Add(n1, aLI);
	125	}
	126	if (aMILI.Contains(n2)) {
127	BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n2);
128	aLI.Append(n1);
129	}
130	else {
131	BOPCol_ListOfInteger aLI(aAllocator);
132	aLI.Append(n1);
133	aMILI.Add(n2, aLI);
134	}
135	}
136	//=======================================================================
137	//function : FillMap
138	//purpose :
139	//=======================================================================
140	void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
141	const Handle(BOPDS_PaveBlock)& aPB2,
142	BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
143	Handle(NCollection_BaseAllocator)& aAllocator)
144	{
145	if (aMPBLPB.Contains(aPB1)) {
146	BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB1);
147	aLPB.Append(aPB2);
148	}
149	else {
150	BOPDS_ListOfPaveBlock aLPB(aAllocator);
151	aLPB.Append(aPB2);
152	aMPBLPB.Add(aPB1, aLPB);
153	}
154	if (aMPBLPB.Contains(aPB2)) {
155	BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB2);
156	aLPB.Append(aPB1);
157	}
158	else {
159	BOPDS_ListOfPaveBlock aLPB(aAllocator);
160	aLPB.Append(aPB1);
161	aMPBLPB.Add(aPB2, aLPB);
162	}
163	}
164	//=======================================================================
165	//function : FillMap
166	//purpose :
167	//=======================================================================
168	void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
169	const Standard_Integer nF,
170	BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
171	Handle(NCollection_BaseAllocator)& aAllocator)
172	{
173	if (aMPBLI.Contains(aPB)) {
174	BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
175	aLI.Append(nF);
176	}
177	else {
178	BOPCol_ListOfInteger aLI(aAllocator);
179	aLI.Append(nF);
180	aMPBLI.Add(aPB, aLI);
181	}
182	}
183	//=======================================================================
184	//function : MakeBlocks
185	//purpose :
186	//=======================================================================
187	void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
188	BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
189	Handle(NCollection_BaseAllocator)& aAllocator)
190	{
191	Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
192	BOPDS_ListIteratorOfListOfPaveBlock aItLI;
193	//
194	BOPDS_MapOfPaveBlock aMVS(100, aAllocator);
195	BOPDS_IndexedMapOfPaveBlock aMEC(100, aAllocator);
196	BOPDS_IndexedMapOfPaveBlock aMVP(100, aAllocator);
197	BOPDS_IndexedMapOfPaveBlock aMVAdd(100, aAllocator);
198	//
199	aNbV=aMILI.Extent();
200	//
201	for (k=0, i=1; i<=aNbV; ++i) {
202	aNbVS=aMVS.Extent();
203	if (aNbVS==aNbV) {
204	break;
205	}
206	//
207	const Handle(BOPDS_PaveBlock)& nV=aMILI.FindKey(i);
208	if (aMVS.Contains(nV)){
209	continue;
210	}
211	aMVS.Add(nV);
212	//
213	aMEC.Clear();
214	aMVP.Clear();
215	aMVAdd.Clear();
216	//
217	aMVP.Add(nV);
302f96fb	218	for(;;) {
4e57c75e	219	aNbVP=aMVP.Extent();
	220	for (j=1; j<=aNbVP; ++j) {
	221	const Handle(BOPDS_PaveBlock)& nVP=aMVP(j);
	222	const BOPDS_ListOfPaveBlock& aLV=aMILI.FindFromKey(nVP);
	223	aItLI.Initialize(aLV);
	224	for (; aItLI.More(); aItLI.Next()) {
	225	const Handle(BOPDS_PaveBlock)& nVx=aItLI.Value();
	226	if (aMEC.Contains(nVx)) {
	227	continue;
	228	}
	229	//
	230	aMVS.Add(nVx);
	231	aMEC.Add(nVx);
	232	aMVAdd.Add(nVx);
	233	}
	234	}
	235	//
	236	aNbVP=aMVAdd.Extent();
	237	if (!aNbVP) {
	238	break; // from while(1)
	239	}
	240	//
	241	aMVP.Clear();
	242	for (j=1; j<=aNbVP; ++j) {
	243	aMVP.Add(aMVAdd(j));
	244	}
	245	aMVAdd.Clear();
	246	}//while(1) {
	247	//
	248	BOPDS_ListOfPaveBlock aLIx(aAllocator);
	249	//
	250	aNbEC = aMEC.Extent();
	251	for (j=1; j<=aNbEC; ++j) {
	252	const Handle(BOPDS_PaveBlock)& nVx=aMEC(j);
	253	aLIx.Append(nVx);
	254	}
	255	//
	256	aMBlocks.Bind(k, aLIx);
	257	++k;
	258	}//for (k=0, i=1; i<=aNbV; ++i)
	259	aMVAdd.Clear();
	260	aMVP.Clear();
	261	aMEC.Clear();
	262	aMVS.Clear();
	263	}
	264	//=======================================================================
	265	//function : PerformCommonBlocks
	266	//purpose :
	267	//=======================================================================
	268	void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
5a77460e	269	Handle(NCollection_BaseAllocator)& aAllocator,
5a77460e	270	BOPDS_PDS& pDS)
4e57c75e	271	{
	272	Standard_Integer aNbCB;
	273	//
	274	aNbCB=aMPBLPB.Extent();
	275	if (!aNbCB) {
	276	return;
	277	}
	278	//
	279	Standard_Integer aNbPB, aNbBlocks, k;
	280	BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
	281	Handle(BOPDS_CommonBlock) aCB;
	282	BOPDS_DataMapOfIntegerListOfPaveBlock aMBlocks(100, aAllocator);
	283	//
	284	BOPAlgo_Tools::MakeBlocks(aMPBLPB, aMBlocks, aAllocator);
	285	//
	286	aNbBlocks = aMBlocks.Extent();
	287	for (k=0; k<aNbBlocks; ++k) {
	288	const BOPDS_ListOfPaveBlock& aLPB=aMBlocks.Find(k);
	289	aNbPB=aLPB.Extent();
	290	if (aNbPB>1) {
	291	aCB=new BOPDS_CommonBlock;
	292	//
	293	aItLPB.Initialize(aLPB);
	294	for (; aItLPB.More(); aItLPB.Next()) {
	295	const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
	296	aCB->AddPaveBlock(aPBx);
	297	}
	298	//
	299	aItLPB.Initialize(aLPB);
	300	for (; aItLPB.More(); aItLPB.Next()) {
	301	const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
5a77460e	302	pDS->SetCommonBlock(aPBx, aCB);
4e57c75e	303	}
	304	}//if (aNbPB>1) {
	305	}
	306	}
	307	//=======================================================================
	308	//function : PerformCommonBlocks
	309	//purpose :
	310	//=======================================================================
	311	void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
5a77460e	312	Handle(NCollection_BaseAllocator)& ,//aAllocator
5a77460e	313	BOPDS_PDS& pDS)
4e57c75e	314	{
	315	Standard_Integer nF, i, aNb;
	316	BOPCol_ListIteratorOfListOfInteger aItLI;
	317	Handle(BOPDS_PaveBlock) aPB;
	318	Handle(BOPDS_CommonBlock) aCB;
	319	//
	320	aNb=aMPBLI.Extent();
	321	for (i=1; i<=aNb; ++i) {
	322	aPB=aMPBLI.FindKey(i);
5a77460e	323	if (pDS->IsCommonBlock(aPB)) {
5a77460e	324	aCB=pDS->CommonBlock(aPB);
4e57c75e	325	}
	326	else {
	327	aCB=new BOPDS_CommonBlock;
	328	aCB->AddPaveBlock(aPB);
	329	}
	330	//
	331	const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
	332	aItLI.Initialize(aLI);
	333	for (; aItLI.More(); aItLI.Next()) {
	334	nF=aItLI.Value();
	335	aCB->AddFace(nF);
	336	}
5a77460e	337	pDS->SetCommonBlock(aPB, aCB);
4e57c75e	338	}
4e57c75e	339	}