[occt.git] / src / TopOpeBRepBuild / TopOpeBRepBuild_Area1dBuilder.cxx

// Created on: 1995-12-21
// Created by: Jean Yves LEBEY
// Copyright (c) 1995-1999 Matra Datavision
// 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 <TopOpeBRepBuild_Area1dBuilder.ixx>

#include <TopOpeBRepBuild_Pave.hxx>
#include <TopOpeBRepBuild_LoopEnum.hxx>
#include <Standard_DomainError.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopAbs.hxx>

#ifdef DEB
extern Standard_Boolean TopOpeBRepBuild_GettraceAREA();
extern Standard_Boolean TopOpeBRepDS_GettraceSTRANGE();
#endif

//=======================================================================
//function : DumpList
//purpose  : 
//=======================================================================

#ifdef DEB
void TopOpeBRepBuild_Area1dBuilder::DumpList(const TopOpeBRepBuild_ListOfLoop& LOL)
{
  Standard_Integer iLOL;
  TopOpeBRepBuild_ListIteratorOfListOfLoop  itLOL;
  for (iLOL = 0, itLOL.Initialize(LOL); itLOL.More(); iLOL++, itLOL.Next()) {
    if (iLOL) cout<<"               ";
    else     cout<<"DUMP_AREA    : ";
    const Handle(TopOpeBRepBuild_Loop)& L = itLOL.Value();
    L->Dump();cout<<endl;
  }
#else
void TopOpeBRepBuild_Area1dBuilder::DumpList(const TopOpeBRepBuild_ListOfLoop&)
{
#endif
}

//=======================================================================
//function : TopOpeBRepBuild_Area1dBuilder
//purpose  : 
//=======================================================================

TopOpeBRepBuild_Area1dBuilder::TopOpeBRepBuild_Area1dBuilder()
{
}

//=======================================================================
//function : TopOpeBRepBuild_Area1dBuilder
//purpose  : 
//=======================================================================

TopOpeBRepBuild_Area1dBuilder::TopOpeBRepBuild_Area1dBuilder
(TopOpeBRepBuild_PaveSet&        LS,
 TopOpeBRepBuild_PaveClassifier& LC,
 const Standard_Boolean ForceClass)
{
   InitAreaBuilder(LS,LC,ForceClass);
}

//=======================================================================
//function : InitAreaBuilder
//purpose  : 
//=======================================================================

void TopOpeBRepBuild_Area1dBuilder::InitAreaBuilder
(TopOpeBRepBuild_LoopSet&        LS,
 TopOpeBRepBuild_LoopClassifier& LC,
 const Standard_Boolean ForceClass)
{
  TopAbs_State     state;
  Standard_Boolean Loopinside;
  Standard_Boolean loopoutside;
  
  TopOpeBRepBuild_ListIteratorOfListOfListOfLoop AreaIter;
  TopOpeBRepBuild_ListIteratorOfListOfLoop       LoopIter;
  // boundaryloops : list of boundary loops out of the areas.
  TopOpeBRepBuild_ListOfLoop                     boundaryloops; 
  
  myArea.Clear();          // Clear the list of Area to be built
  
  for (LS.InitLoop(); LS.MoreLoop(); LS.NextLoop()) {
    
    // process a new loop : L is the new current Loop
    const Handle(TopOpeBRepBuild_Loop)& L = LS.Loop();
    Standard_Boolean boundaryL = L->IsShape();
                
#ifdef DEB
    if (TopOpeBRepBuild_GettraceAREA()) {
      cout<<"++++ new loop : "; L->Dump();
      if (boundaryL) cout<<" is bound"; else cout<<" is not bound";
      cout<<endl;
    }
#endif


    // L = shape et ForceClass  : on traite L comme un block
    // L = shape et !ForceClass : on traite L comme un pur shape
    // L = !shape               : on traite L comme un block
    Standard_Boolean traitercommeblock = !boundaryL || ForceClass;
     if ( ! traitercommeblock ) {

      // the loop L is a boundary loop : 
      // - try to insert it in an existing area, such as L is inside all 
      //   the block loops. Only block loops of the area are compared. 
      // - if L could not be inserted, store it in list of boundary loops.

        Loopinside = Standard_False; 
        for (AreaIter.Initialize(myArea); AreaIter.More(); AreaIter.Next()) {
	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
	if ( aArea.IsEmpty() ) continue;
	state = CompareLoopWithListOfLoop(LC,L,aArea,TopOpeBRepBuild_BLOCK);
	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
	Loopinside = ( state == TopAbs_IN);
	if ( Loopinside ) break;
	} // end of Area scan

	 if ( Loopinside ) {
	   TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
	    ADD_Loop_TO_LISTOFLoop(L,aArea,(void*)("IN, to current area"));
	  }
	  else if ( ! Loopinside ) {
	     ADD_Loop_TO_LISTOFLoop(L,boundaryloops,(void*)("! IN, to boundaryloops"));
	}

    } // end of boundary loop
    
       else { 
      // the loop L is a block loop
      // if L is IN theArea :
      //   - stop area scan, insert L in theArea.
      //   - remove from the area all the loops outside L
      //   - make a new area with them, unless they are all boundary
      //   - if they are all boundary put them back in boundaryLoops
      // else :
      //   - create a new area with L.
      //   - insert boundary loops that are IN the new area
      //     (and remove them from 'boundaryloops')
      
      Loopinside = Standard_False;
      for (AreaIter.Initialize(myArea); AreaIter.More(); AreaIter.Next() ) {
	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
	if ( aArea.IsEmpty() ) continue;
 	state = CompareLoopWithListOfLoop(LC,L,aArea,TopOpeBRepBuild_ANYLOOP);
	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
 	Loopinside = (state == TopAbs_IN);
	if ( Loopinside ) break;
      } // end of Area scan
      
      if ( Loopinside) {
	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
	Standard_Boolean allShape = Standard_True;
	TopOpeBRepBuild_ListOfLoop removedLoops;
	LoopIter.Initialize(aArea);
	while (LoopIter.More()) {
	  state = LC.Compare(LoopIter.Value(),L);
	  if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN); // not OUT
	  loopoutside = ( state == TopAbs_OUT );
	  if ( loopoutside ) {
	    const Handle(TopOpeBRepBuild_Loop)& curL = LoopIter.Value();
	    // remove the loop from the area
	    ADD_Loop_TO_LISTOFLoop
	      (curL,removedLoops,(void*)("loopoutside = 1, area = removedLoops"));

	    allShape = allShape && curL->IsShape();
	    REM_Loop_FROM_LISTOFLoop
	      (LoopIter,AreaIter.Value(),(void*)("loop of cur. area, cur. area"));
	  }
	  else {
	    LoopIter.Next();
	  }
	}
	// insert the loop in the area
	ADD_Loop_TO_LISTOFLoop(L,aArea,(void*)("area = current"));
	if ( ! removedLoops.IsEmpty() ) {
	  if ( allShape ) {
	    ADD_LISTOFLoop_TO_LISTOFLoop
	      (removedLoops,boundaryloops,
	       (void*)("allShape = 1"),(void*)("removedLoops"),(void*)("boundaryloops"));
	  }
      else {
	    // make a new area with the removed loops
  	    TopOpeBRepBuild_ListOfLoop thelist;
            myArea.Append(thelist);
	    ADD_LISTOFLoop_TO_LISTOFLoop
	      (removedLoops,myArea.Last(),
	       (void*)("allShape = 0"),(void*)("removedLoops"),(void*)("new area"));
	  }
	}
      } // Loopinside == True
      
      else {
        Standard_Integer ashapeinside,ablockinside;
	TopOpeBRepBuild_ListOfLoop thelist1;
	myArea.Append(thelist1);
	TopOpeBRepBuild_ListOfLoop& newArea0 = myArea.Last();
	ADD_Loop_TO_LISTOFLoop(L,newArea0,(void*)("new area"));
	
        LoopIter.Initialize(boundaryloops);
        while ( LoopIter.More() ) {
          ashapeinside = ablockinside = Standard_False;
	  state = LC.Compare(LoopIter.Value(),L);
	  if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
          ashapeinside = (state == TopAbs_IN);
          if (ashapeinside) {
	    state = LC.Compare(L,LoopIter.Value());
	    if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
	    ablockinside = (state == TopAbs_IN);
	  }
	  if ( ashapeinside && ablockinside ) {
	    const Handle(TopOpeBRepBuild_Loop)& curL = LoopIter.Value();
	    ADD_Loop_TO_LISTOFLoop
	      (curL,newArea0,(void*)("ashapeinside && ablockinside, new area"));

	    REM_Loop_FROM_LISTOFLoop
	      (LoopIter,boundaryloops,(void*)("loop of boundaryloops, boundaryloops"));
	  }
          else { 
	    LoopIter.Next();
	  }
	} // end of boundaryloops scan
      } // Loopinside == False
    } // end of block loop
  } // end of LoopSet LS scan
  
#ifdef DEB
  if (TopOpeBRepBuild_GettraceAREA()) {
    if ( ! myArea.IsEmpty() ) {
      cout<<"------- Areas -------"<<endl;
      for (AreaIter.Initialize(myArea);AreaIter.More();AreaIter.Next())
	DumpList(AreaIter.Value());
      cout<<"---------------------"<<endl;
    }
  }
#endif
  
 InitArea();
}

//=======================================================================
//function : ADD_Loop_TO_LISTOFLoop
//purpose  : 
//=======================================================================

void TopOpeBRepBuild_Area1dBuilder::ADD_Loop_TO_LISTOFLoop
(const Handle(TopOpeBRepBuild_Loop)& L,
 TopOpeBRepBuild_ListOfLoop& LOL,
 const Standard_Address
#ifdef DEB
  ss
#endif
  ) const
{
  LOL.Append(L);
  
#ifdef DEB
  if (TopOpeBRepBuild_GettraceAREA()) {
    cout<<"--------------------- add area loop to area : ";
    L->Dump(); cout<<endl;
    if (ss != NULL) cout<<(char*)ss<<endl;
    DumpList(LOL);
    cout<<"---------------------"<<endl;
  }
#endif
 }

//=======================================================================
//function : REM_Loop_FROM_LISTOFLoop
//purpose  : 
//=======================================================================

void TopOpeBRepBuild_Area1dBuilder::REM_Loop_FROM_LISTOFLoop
(TopOpeBRepBuild_ListIteratorOfListOfLoop& ITA,
 TopOpeBRepBuild_ListOfLoop& A,
#ifdef DEB
 const Standard_Address ss) const
{
  char* s = (char*)ss;
#else
const Standard_Address) const
{
#endif

#ifdef DEB
  if (TopOpeBRepBuild_GettraceAREA()) {
    if (ITA.More()) {
      cout<<"--------------------- remove area loop from area : ";
      ITA.Value()->Dump(); cout<<endl;
      if (s != NULL) cout<<s<<endl;
    }
  }
#endif
  
  A.Remove(ITA);
  
#ifdef DEB
  if (TopOpeBRepBuild_GettraceAREA()) {
    DumpList(A);
    cout<<"---------------------"<<endl;
  }
#endif
}

//=======================================================================
//function : ADD_LISTOFLoop_TO_LISTOFLoop
//purpose  : 
//=======================================================================

void TopOpeBRepBuild_Area1dBuilder::ADD_LISTOFLoop_TO_LISTOFLoop
(TopOpeBRepBuild_ListOfLoop& A1,
 TopOpeBRepBuild_ListOfLoop& A2,
 #ifdef DEB
 const Standard_Address ss,
 const Standard_Address ss1,
 const Standard_Address ss2) const
#else
 const Standard_Address,
 const Standard_Address,
 const Standard_Address) const
#endif
{
#ifdef DEB
  char* s  = (char*)ss;
  char* s1 = (char*)ss1;
  char* s2 = (char*)ss2;

  if (TopOpeBRepBuild_GettraceAREA()) {
    cout<<"--------------------- add area 1 to area 2 : ";
    if (s != NULL) cout<<s;  cout<<endl;
    cout<<"1 : "; if (s1 != NULL) cout<<s1; cout<<endl;
    DumpList(A1);
  }
#endif
  
  A2.Append(A1);
  
#ifdef DEB
  if (TopOpeBRepBuild_GettraceAREA()) {
    cout<<"2 : "; if (s2 != NULL) cout<<s2; cout<<endl;
    DumpList(A2);
    cout<<"---------------------"<<endl;
  }
#endif
}
Commit	Line	Data
b311480e	1	// Created on: 1995-12-21
	2	// Created by: Jean Yves LEBEY
	3	// Copyright (c) 1995-1999 Matra Datavision
	4	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	5	//
	6	// The content of this file is subject to the Open CASCADE Technology Public
	7	// License Version 6.5 (the "License"). You may not use the content of this file
	8	// except in compliance with the License. Please obtain a copy of the License
	9	// at http://www.opencascade.org and read it completely before using this file.
	10	//
	11	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	12	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	13	//
	14	// The Original Code and all software distributed under the License is
	15	// distributed on an "AS IS" basis, without warranty of any kind, and the
	16	// Initial Developer hereby disclaims all such warranties, including without
	17	// limitation, any warranties of merchantability, fitness for a particular
	18	// purpose or non-infringement. Please see the License for the specific terms
	19	// and conditions governing the rights and limitations under the License.
	20
7fd59977	21
	22	#include <TopOpeBRepBuild_Area1dBuilder.ixx>
	23
	24	#include <TopOpeBRepBuild_Pave.hxx>
	25	#include <TopOpeBRepBuild_LoopEnum.hxx>
	26	#include <Standard_DomainError.hxx>
	27	#include <TopAbs_ShapeEnum.hxx>
	28	#include <TopAbs_Orientation.hxx>
	29	#include <TopAbs.hxx>
	30
	31	#ifdef DEB
1d0a9d4d	32	extern Standard_Boolean TopOpeBRepBuild_GettraceAREA();
1d0a9d4d	33	extern Standard_Boolean TopOpeBRepDS_GettraceSTRANGE();
7fd59977	34	#endif
	35
	36	//=======================================================================
	37	//function : DumpList
	38	//purpose :
	39	//=======================================================================
	40
498ce76b	41	#ifdef DEB
7fd59977	42	void TopOpeBRepBuild_Area1dBuilder::DumpList(const TopOpeBRepBuild_ListOfLoop& LOL)
7fd59977	43	{
7fd59977	44	Standard_Integer iLOL;
	45	TopOpeBRepBuild_ListIteratorOfListOfLoop itLOL;
	46	for (iLOL = 0, itLOL.Initialize(LOL); itLOL.More(); iLOL++, itLOL.Next()) {
	47	if (iLOL) cout<<" ";
	48	else cout<<"DUMP_AREA : ";
	49	const Handle(TopOpeBRepBuild_Loop)& L = itLOL.Value();
	50	L->Dump();cout<<endl;
	51	}
498ce76b	52	#else
	53	void TopOpeBRepBuild_Area1dBuilder::DumpList(const TopOpeBRepBuild_ListOfLoop&)
	54	{
7fd59977	55	#endif
	56	}
	57
	58	//=======================================================================
	59	//function : TopOpeBRepBuild_Area1dBuilder
	60	//purpose :
	61	//=======================================================================
	62
	63	TopOpeBRepBuild_Area1dBuilder::TopOpeBRepBuild_Area1dBuilder()
	64	{
	65	}
	66
	67	//=======================================================================
	68	//function : TopOpeBRepBuild_Area1dBuilder
	69	//purpose :
	70	//=======================================================================
	71
	72	TopOpeBRepBuild_Area1dBuilder::TopOpeBRepBuild_Area1dBuilder
	73	(TopOpeBRepBuild_PaveSet& LS,
	74	TopOpeBRepBuild_PaveClassifier& LC,
	75	const Standard_Boolean ForceClass)
	76	{
	77	InitAreaBuilder(LS,LC,ForceClass);
	78	}
	79
	80	//=======================================================================
	81	//function : InitAreaBuilder
	82	//purpose :
	83	//=======================================================================
	84
	85	void TopOpeBRepBuild_Area1dBuilder::InitAreaBuilder
	86	(TopOpeBRepBuild_LoopSet& LS,
	87	TopOpeBRepBuild_LoopClassifier& LC,
	88	const Standard_Boolean ForceClass)
	89	{
	90	TopAbs_State state;
	91	Standard_Boolean Loopinside;
	92	Standard_Boolean loopoutside;
	93
	94	TopOpeBRepBuild_ListIteratorOfListOfListOfLoop AreaIter;
	95	TopOpeBRepBuild_ListIteratorOfListOfLoop LoopIter;
	96	// boundaryloops : list of boundary loops out of the areas.
	97	TopOpeBRepBuild_ListOfLoop boundaryloops;
	98
	99	myArea.Clear(); // Clear the list of Area to be built
	100
	101	for (LS.InitLoop(); LS.MoreLoop(); LS.NextLoop()) {
	102
	103	// process a new loop : L is the new current Loop
	104	const Handle(TopOpeBRepBuild_Loop)& L = LS.Loop();
	105	Standard_Boolean boundaryL = L->IsShape();
	106
	107	#ifdef DEB
	108	if (TopOpeBRepBuild_GettraceAREA()) {
	109	cout<<"++++ new loop : "; L->Dump();
	110	if (boundaryL) cout<<" is bound"; else cout<<" is not bound";
	111	cout<<endl;
	112	}
	113	#endif
	114
	115
	116	// L = shape et ForceClass : on traite L comme un block
	117	// L = shape et !ForceClass : on traite L comme un pur shape
	118	// L = !shape : on traite L comme un block
119	Standard_Boolean traitercommeblock = !boundaryL \|\| ForceClass;
120	if ( ! traitercommeblock ) {
121
122	// the loop L is a boundary loop :
123	// - try to insert it in an existing area, such as L is inside all
124	// the block loops. Only block loops of the area are compared.
125	// - if L could not be inserted, store it in list of boundary loops.
126
127	Loopinside = Standard_False;
128	for (AreaIter.Initialize(myArea); AreaIter.More(); AreaIter.Next()) {
129	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
130	if ( aArea.IsEmpty() ) continue;
131	state = CompareLoopWithListOfLoop(LC,L,aArea,TopOpeBRepBuild_BLOCK);
132	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
133	Loopinside = ( state == TopAbs_IN);
134	if ( Loopinside ) break;
135	} // end of Area scan
136
137	if ( Loopinside ) {
138	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
139	ADD_Loop_TO_LISTOFLoop(L,aArea,(void*)("IN, to current area"));
140	}
141	else if ( ! Loopinside ) {
142	ADD_Loop_TO_LISTOFLoop(L,boundaryloops,(void*)("! IN, to boundaryloops"));
143	}
144
145	} // end of boundary loop
146
147	else {
148	// the loop L is a block loop
149	// if L is IN theArea :
150	// - stop area scan, insert L in theArea.
151	// - remove from the area all the loops outside L
152	// - make a new area with them, unless they are all boundary
153	// - if they are all boundary put them back in boundaryLoops
154	// else :
155	// - create a new area with L.
156	// - insert boundary loops that are IN the new area
157	// (and remove them from 'boundaryloops')
158
159	Loopinside = Standard_False;
160	for (AreaIter.Initialize(myArea); AreaIter.More(); AreaIter.Next() ) {
161	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
162	if ( aArea.IsEmpty() ) continue;
163	state = CompareLoopWithListOfLoop(LC,L,aArea,TopOpeBRepBuild_ANYLOOP);
164	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
165	Loopinside = (state == TopAbs_IN);
166	if ( Loopinside ) break;
167	} // end of Area scan
168
169	if ( Loopinside) {
170	TopOpeBRepBuild_ListOfLoop& aArea = AreaIter.Value();
171	Standard_Boolean allShape = Standard_True;
172	TopOpeBRepBuild_ListOfLoop removedLoops;
173	LoopIter.Initialize(aArea);
174	while (LoopIter.More()) {
175	state = LC.Compare(LoopIter.Value(),L);
176	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN); // not OUT
177	loopoutside = ( state == TopAbs_OUT );
178	if ( loopoutside ) {
179	const Handle(TopOpeBRepBuild_Loop)& curL = LoopIter.Value();
180	// remove the loop from the area
181	ADD_Loop_TO_LISTOFLoop
182	(curL,removedLoops,(void*)("loopoutside = 1, area = removedLoops"));
183
184	allShape = allShape && curL->IsShape();
185	REM_Loop_FROM_LISTOFLoop
186	(LoopIter,AreaIter.Value(),(void*)("loop of cur. area, cur. area"));
187	}
188	else {
189	LoopIter.Next();
190	}
191	}
192	// insert the loop in the area
193	ADD_Loop_TO_LISTOFLoop(L,aArea,(void*)("area = current"));
194	if ( ! removedLoops.IsEmpty() ) {
195	if ( allShape ) {
196	ADD_LISTOFLoop_TO_LISTOFLoop
197	(removedLoops,boundaryloops,
198	(void)("allShape = 1"),(void)("removedLoops"),(void*)("boundaryloops"));
199	}
200	else {
201	// make a new area with the removed loops
202	TopOpeBRepBuild_ListOfLoop thelist;
203	myArea.Append(thelist);
204	ADD_LISTOFLoop_TO_LISTOFLoop
205	(removedLoops,myArea.Last(),
206	(void)("allShape = 0"),(void)("removedLoops"),(void*)("new area"));
207	}
208	}
209	} // Loopinside == True
210
211	else {
212	Standard_Integer ashapeinside,ablockinside;
213	TopOpeBRepBuild_ListOfLoop thelist1;
214	myArea.Append(thelist1);
215	TopOpeBRepBuild_ListOfLoop& newArea0 = myArea.Last();
216	ADD_Loop_TO_LISTOFLoop(L,newArea0,(void*)("new area"));
217
218	LoopIter.Initialize(boundaryloops);
219	while ( LoopIter.More() ) {
220	ashapeinside = ablockinside = Standard_False;
221	state = LC.Compare(LoopIter.Value(),L);
222	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
223	ashapeinside = (state == TopAbs_IN);
224	if (ashapeinside) {
225	state = LC.Compare(L,LoopIter.Value());
226	if (state == TopAbs_UNKNOWN) Atomize(state,TopAbs_IN);
227	ablockinside = (state == TopAbs_IN);
228	}
229	if ( ashapeinside && ablockinside ) {
230	const Handle(TopOpeBRepBuild_Loop)& curL = LoopIter.Value();
231	ADD_Loop_TO_LISTOFLoop
232	(curL,newArea0,(void*)("ashapeinside && ablockinside, new area"));
233
234	REM_Loop_FROM_LISTOFLoop
235	(LoopIter,boundaryloops,(void*)("loop of boundaryloops, boundaryloops"));
236	}
237	else {
238	LoopIter.Next();
239	}
240	} // end of boundaryloops scan
241	} // Loopinside == False
242	} // end of block loop
243	} // end of LoopSet LS scan
244
245	#ifdef DEB
246	if (TopOpeBRepBuild_GettraceAREA()) {
247	if ( ! myArea.IsEmpty() ) {
248	cout<<"------- Areas -------"<<endl;
249	for (AreaIter.Initialize(myArea);AreaIter.More();AreaIter.Next())
250	DumpList(AreaIter.Value());
251	cout<<"---------------------"<<endl;
252	}
253	}
254	#endif
255
256	InitArea();
257	}
258
259	//=======================================================================
260	//function : ADD_Loop_TO_LISTOFLoop
261	//purpose :
262	//=======================================================================
263
264	void TopOpeBRepBuild_Area1dBuilder::ADD_Loop_TO_LISTOFLoop
265	(const Handle(TopOpeBRepBuild_Loop)& L,
266	TopOpeBRepBuild_ListOfLoop& LOL,
498ce76b	267	const Standard_Address
7fd59977	268	#ifdef DEB
498ce76b	269	ss
7fd59977	270	#endif
498ce76b	271	) const
498ce76b	272	{
7fd59977	273	LOL.Append(L);
	274
	275	#ifdef DEB
	276	if (TopOpeBRepBuild_GettraceAREA()) {
	277	cout<<"--------------------- add area loop to area : ";
	278	L->Dump(); cout<<endl;
498ce76b	279	if (ss != NULL) cout<<(char*)ss<<endl;
7fd59977	280	DumpList(LOL);
	281	cout<<"---------------------"<<endl;
	282	}
	283	#endif
	284	}
	285
	286	//=======================================================================
	287	//function : REM_Loop_FROM_LISTOFLoop
	288	//purpose :
	289	//=======================================================================
	290
	291	void TopOpeBRepBuild_Area1dBuilder::REM_Loop_FROM_LISTOFLoop
	292	(TopOpeBRepBuild_ListIteratorOfListOfLoop& ITA,
	293	TopOpeBRepBuild_ListOfLoop& A,
498ce76b	294	#ifdef DEB
7fd59977	295	const Standard_Address ss) const
7fd59977	296	{
7fd59977	297	char* s = (char*)ss;
498ce76b	298	#else
	299	const Standard_Address) const
	300	{
7fd59977	301	#endif
	302
	303	#ifdef DEB
	304	if (TopOpeBRepBuild_GettraceAREA()) {
	305	if (ITA.More()) {
	306	cout<<"--------------------- remove area loop from area : ";
	307	ITA.Value()->Dump(); cout<<endl;
	308	if (s != NULL) cout<<s<<endl;
	309	}
	310	}
	311	#endif
	312
	313	A.Remove(ITA);
	314
	315	#ifdef DEB
	316	if (TopOpeBRepBuild_GettraceAREA()) {
	317	DumpList(A);
	318	cout<<"---------------------"<<endl;
	319	}
	320	#endif
	321	}
	322
	323	//=======================================================================
	324	//function : ADD_LISTOFLoop_TO_LISTOFLoop
	325	//purpose :
	326	//=======================================================================
	327
	328	void TopOpeBRepBuild_Area1dBuilder::ADD_LISTOFLoop_TO_LISTOFLoop
	329	(TopOpeBRepBuild_ListOfLoop& A1,
	330	TopOpeBRepBuild_ListOfLoop& A2,
498ce76b	331	#ifdef DEB
7fd59977	332	const Standard_Address ss,
	333	const Standard_Address ss1,
	334	const Standard_Address ss2) const
498ce76b	335	#else
	336	const Standard_Address,
	337	const Standard_Address,
	338	const Standard_Address) const
	339	#endif
7fd59977	340	{
	341	#ifdef DEB
	342	char* s = (char*)ss;
	343	char* s1 = (char*)ss1;
	344	char* s2 = (char*)ss2;
	345
	346	if (TopOpeBRepBuild_GettraceAREA()) {
	347	cout<<"--------------------- add area 1 to area 2 : ";
	348	if (s != NULL) cout<<s; cout<<endl;
	349	cout<<"1 : "; if (s1 != NULL) cout<<s1; cout<<endl;
	350	DumpList(A1);
	351	}
	352	#endif
	353
	354	A2.Append(A1);
	355
	356	#ifdef DEB
	357	if (TopOpeBRepBuild_GettraceAREA()) {
	358	cout<<"2 : "; if (s2 != NULL) cout<<s2; cout<<endl;
	359	DumpList(A2);
	360	cout<<"---------------------"<<endl;
	361	}
	362	#endif
	363	}
	364
	365
	366
	367
	368
	369
	370
	371
	372