[occt.git] / src / IntPolyh / IntPolyh_Intersection.cxx

// Created on: 1999-03-03
// Created by: Fabrice SERVANT
// Copyright (c) 1999-1999 Matra Datavision
// 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.

//  modified by Edward AGAPOV (eap) Tue Jan 22 12:29:55 2002 (occ53)
//  Modified by skv - Thu Sep 25 18:24:29 2003 OCC567

#include <IntPolyh_Intersection.ixx>
#include <IntPolyh_SectionLine.hxx>
#include <IntPolyh_StartPoint.hxx>
#include <IntPolyh_MaillageAffinage.hxx>
#include <IntPolyh_Couple.hxx>
#include <IntPolyh_Triangle.hxx>

Standard_Integer MYDISPLAY = 0;
Standard_Integer MYPRINT   = 0;

IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
					     const Handle(Adaptor3d_HSurface)& S2)
{
  myNbSU1 = -1;
  myNbSV1 = -1;
  myNbSU2 = -1; 
  myNbSV2 = -1; 
  mySurf1 = S1;
  mySurf2 = S2;
  done = Standard_False;
  TSectionLines.Init(1000);
  TTangentZones.Init(10000);
  Perform();
}

IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
					     const Standard_Integer NbSU1,
					     const Standard_Integer NbSV1,
					     const Handle(Adaptor3d_HSurface)& S2,
					     const Standard_Integer NbSU2,
					     const Standard_Integer NbSV2)
{
  myNbSU1 = NbSU1;
  myNbSV1 = NbSV1;
  myNbSU2 = NbSU2; 
  myNbSV2 = NbSV2; 
  mySurf1 = S1;
  mySurf2 = S2;
  done = Standard_False;
  TSectionLines.Init(1000);
  TTangentZones.Init(10000);
  Perform();
}

void IntPolyh_Intersection::Perform() { 

  done = Standard_True;

  Standard_Boolean startFromAdvanced = Standard_False;
  Standard_Boolean isStdDone = Standard_False;
  Standard_Boolean isAdvDone = Standard_False;
  Standard_Integer nbCouplesStd = 0;
  Standard_Integer nbCouplesAdv = 0;
  
  //GeomAbs_SurfaceType ST1 = mySurf1->GetType();
  //GeomAbs_SurfaceType ST2 = mySurf2->GetType();

//   if(ST1 == GeomAbs_Torus || ST2 == GeomAbs_Torus)
//     startFromAdvanced = Standard_True;
  
  IntPolyh_PMaillageAffinage aPMaillageStd = 0;
  IntPolyh_PMaillageAffinage aPMaillageFF = 0;
  IntPolyh_PMaillageAffinage aPMaillageFR = 0;
  IntPolyh_PMaillageAffinage aPMaillageRF = 0;
  IntPolyh_PMaillageAffinage aPMaillageRR = 0;


  if(!startFromAdvanced) {

    isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);

    // default interference done well, use it
    if(isStdDone && nbCouplesStd > 10) {
      aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
    }
    // default interference done, but too few interferences foud;
    // use advanced interference
    else if(isStdDone && nbCouplesStd <= 10) {
      isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
      
      // advanced interference found
      if(isAdvDone && nbCouplesAdv > 10) {
	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
      }
      else {
	// use result of default
	if(nbCouplesStd > 0)
	  aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
      }
    }
    // default interference faild, use advanced
    else {
//       isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
      
//       if(isAdvDone && nbCouplesAdv > 0) {cout << "4adv done, nbc: " << nbCouplesAdv << endl;
// 	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
// 	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
// 	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
// 	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
//       }
    }
  }// start from default
  else {
    
    isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);

    // advanced done, interference found; use it
    if(isAdvDone) {

      if(nbCouplesAdv > 0) {
	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
      }
      else {
	isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
	if(isStdDone && nbCouplesStd > 0)
	  aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
      }
    }
    else {
      isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
      if(isStdDone && nbCouplesStd > 0)
	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
    }
  } // start from advanced

  // accept result
  nbsectionlines = TSectionLines.NbItems();
  nbtangentzones = TTangentZones.NbItems();

  // clean up
  if(aPMaillageStd) delete aPMaillageStd;
  if(aPMaillageFF) delete aPMaillageFF;
  if(aPMaillageFR) delete aPMaillageFR;
  if(aPMaillageRF) delete aPMaillageRF;
  if(aPMaillageRR) delete aPMaillageRR;

  // verify
  if(!isStdDone && !isAdvDone)
    done = Standard_False;
}


Standard_Boolean IntPolyh_Intersection::IsDone() const {
  return(done);
}


Standard_Integer IntPolyh_Intersection::NbSectionLines() const { 
  return(nbsectionlines);
}


Standard_Integer IntPolyh_Intersection::NbPointsInLine(const Standard_Integer IndexLine) const { 
  
  return(TSectionLines[IndexLine-1].NbStartPoints());
}


Standard_Integer IntPolyh_Intersection::NbPointsInTangentZone(const Standard_Integer) const {   
  //-- IndexLine--;     (pas implemente) Attention : Tableaux de 0 a n-1 
  // eap
  // return(TTangentZones.NbTangentZones());
  return 1;
}


Standard_Integer IntPolyh_Intersection::NbTangentZones() const { 
  return(nbtangentzones);
}


void IntPolyh_Intersection::GetLinePoint(const Standard_Integer Indexl,
				 const Standard_Integer Indexp,
				 Standard_Real &x,
				 Standard_Real &y,
				 Standard_Real &z,
				 Standard_Real &u1,
				 Standard_Real &v1,
				 Standard_Real &u2,
				 Standard_Real &v2,
				 Standard_Real &incidence) const { 
  const IntPolyh_SectionLine  &msl=TSectionLines[Indexl-1];
  const IntPolyh_StartPoint   &sp=msl[Indexp-1];
  x=sp.X();
  y=sp.Y();
  z=sp.Z();
  u1=sp.U1();
  v1=sp.V1();
  u2=sp.U2();
  v2=sp.V2();
  incidence=sp.GetAngle();
}


void IntPolyh_Intersection::GetTangentZonePoint(const Standard_Integer Indexz,
					const Standard_Integer /*Indexp*/,
					Standard_Real &x,
					Standard_Real &y,
					Standard_Real &z,
					Standard_Real &u1,
					Standard_Real &v1,
					Standard_Real &u2,
					Standard_Real &v2) const { 
  //--   Indexz--;    tableaux C
  // eap
  //const IntPolyh_StartPoint   &sp=TTangentZones[Indexp-1];
  const IntPolyh_StartPoint   &sp=TTangentZones[Indexz-1];
  x=sp.X();
  y=sp.Y();
  z=sp.Y();
  u1=sp.U1();
  v1=sp.V1();
  u2=sp.U2();
  v2=sp.V2();
}

//  Modified by skv - Thu Sep 25 18:07:41 2003 OCC567 Begin
//=======================================================================
//function : PerformMaillage
//purpose  : Computes MaillageAffinage
//=======================================================================
Standard_Boolean IntPolyh_Intersection::PerformMaillage
                 (const Standard_Boolean            isFirstFwd,
		  const Standard_Boolean            isSecondFwd,
		        IntPolyh_PMaillageAffinage &theMaillageS)
{
  if (myNbSU1 == -1)
    theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, mySurf2, MYPRINT);
  else
    theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, myNbSU1, myNbSV1,
						 mySurf2, myNbSU2, myNbSV2,
						 MYPRINT);

  theMaillageS->FillArrayOfPnt(1, isFirstFwd);
  theMaillageS->FillArrayOfPnt(2, isSecondFwd);
  
  
  Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
  theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
			  xx0, yy0, zz0, xx1, yy1, zz1);
  
  theMaillageS->FillArrayOfEdges(1);
  theMaillageS->FillArrayOfEdges(2);

  theMaillageS->FillArrayOfTriangles(1);
  theMaillageS->FillArrayOfTriangles(2);
  
  theMaillageS->LinkEdges2Triangles();
  
  theMaillageS->TrianglesDeflectionsRefinementBSB();

  Standard_Integer FinTTC = theMaillageS->TriangleCompare();

  // if too many intersections, consider surfaces parallel (eap)
  if(FinTTC > 200 &&
     (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbItems() ||
      FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbItems()) ) {
    return Standard_False;
  }

  return Standard_True;
}

//=======================================================================
//function : PerformMaillage
//purpose  : Computes MaillageAffinage
//=======================================================================
Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffinage &theMaillageS)
{
  if (myNbSU1 == -1)
    theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, mySurf2, MYPRINT);
  else
    theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, myNbSU1, myNbSV1,
						 mySurf2, myNbSU2, myNbSV2,
						 MYPRINT);

  theMaillageS->FillArrayOfPnt(1);
  theMaillageS->FillArrayOfPnt(2);
  
  
  Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
  theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
			  xx0, yy0, zz0, xx1, yy1, zz1);
  
  theMaillageS->FillArrayOfEdges(1);
  theMaillageS->FillArrayOfEdges(2);

  theMaillageS->FillArrayOfTriangles(1);
  theMaillageS->FillArrayOfTriangles(2);
  
  theMaillageS->LinkEdges2Triangles();
  
  theMaillageS->TrianglesDeflectionsRefinementBSB();

  Standard_Integer FinTTC = theMaillageS->TriangleCompare();

  if( FinTTC == 0 ) {
    Standard_Boolean myZone = Standard_True;
    theMaillageS->SetEnlargeZone( myZone );
    theMaillageS->FillArrayOfPnt(1);
    theMaillageS->FillArrayOfPnt(2);
    theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
			    xx0, yy0, zz0, xx1, yy1, zz1);
    theMaillageS->FillArrayOfEdges(1);
    theMaillageS->FillArrayOfEdges(2);
    theMaillageS->FillArrayOfTriangles(1);
    theMaillageS->FillArrayOfTriangles(2);
    theMaillageS->LinkEdges2Triangles();
    theMaillageS->TrianglesDeflectionsRefinementBSB();
    FinTTC = theMaillageS->TriangleCompare();
    myZone = Standard_False;
    theMaillageS->SetEnlargeZone( myZone );
  }

  /*
  // if too many intersections, consider surfaces parallel (eap)
  if(FinTTC > 200 &&
     (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() ||
      FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
    return Standard_False;
  }
  */
  
  return Standard_True;
}

//=======================================================================
//function : MergeCouples
//purpose  : This method analyzes arrays to find same couples. If some 
//           are detected it leaves the couple in only one array 
//           deleting from others.
//=======================================================================

void IntPolyh_Intersection::MergeCouples
                            (IntPolyh_ArrayOfCouples &anArrayFF,
			     IntPolyh_ArrayOfCouples &anArrayFR,
			     IntPolyh_ArrayOfCouples &anArrayRF,
			     IntPolyh_ArrayOfCouples &anArrayRR) const
{
  // Step 1: Sorting arrays.
  IntPolyh_ArrayOfCouples *anArrays[4];
  Standard_Integer         aNbCouples[4];
  Standard_Integer         i;
  IntPolyh_ArrayOfCouples *aTmpPtr;
  Standard_Integer         aTmpNbr;

  anArrays[0] = &anArrayFF;
  anArrays[1] = &anArrayFR;
  anArrays[2] = &anArrayRF;
  anArrays[3] = &anArrayRR;

  for (i = 0; i < 4; i++)
    aNbCouples[i] = anArrays[i]->NbItems();

  Standard_Boolean isChanged = Standard_True;

  while (isChanged) {
    isChanged = Standard_False;

    for (i = 0; i < 3; i++) {
      if (aNbCouples[i] < aNbCouples[i + 1]) {
	aTmpPtr           = anArrays[i];
	anArrays[i]       = anArrays[i + 1];
	anArrays[i + 1]   = aTmpPtr;
	aTmpNbr           = aNbCouples[i];
	aNbCouples[i]     = aNbCouples[i + 1];
	aNbCouples[i + 1] = aTmpNbr;
	isChanged         = Standard_True;
      }
    }
  }

  // Step 2: Searching for same couples.
  Standard_Integer j;
  Standard_Integer indC1;
  Standard_Integer indC2;

  for (i = 0; i < 3; i++) {
    for (j = i + 1; j < 4; j++) {
      for (indC1 = 1; indC1 <= aNbCouples[i]; indC1++) {
	IntPolyh_Couple &aCouple1 = anArrays[i]->ChangeValue(indC1);

	if (aCouple1.AnalyseFlagValue() == 1)
	  continue;

	for (indC2 = 1; indC2 <= aNbCouples[j]; indC2++) {
	  IntPolyh_Couple &aCouple2 = anArrays[j]->ChangeValue(indC2);

	  if (aCouple2.AnalyseFlagValue() == 1)
	    continue;

	  if (aCouple1.FirstValue()  == aCouple2.FirstValue() &&
	      aCouple1.SecondValue() == aCouple2.SecondValue()) {
	    aCouple2.SetAnalyseFlag(1);
	  }
	}
      }
    }
  }
}
//  Modified by skv - Thu Sep 25 18:07:42 2003 OCC567 End

Standard_Boolean IntPolyh_Intersection::PerformStd(IntPolyh_PMaillageAffinage& MaillageS,
						   Standard_Integer&           NbCouples)
{
  Standard_Boolean isdone = PerformMaillage(MaillageS);
  NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbItems()) : 0;
  return isdone;
}

Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& MaillageFF,
						   IntPolyh_PMaillageAffinage& MaillageFR,
						   IntPolyh_PMaillageAffinage& MaillageRF,
						   IntPolyh_PMaillageAffinage& MaillageRR,
						   Standard_Integer&           NbCouples)
{
  Standard_Boolean isdone = Standard_True;
  NbCouples = 0;

  if(!PerformMaillage(Standard_True,Standard_False,MaillageFR) ||
     !PerformMaillage(Standard_False,Standard_True,MaillageRF) ||
     !PerformMaillage(Standard_True,Standard_True,MaillageFF)  ||
     !PerformMaillage(Standard_False,Standard_False,MaillageRR) )
    isdone = Standard_False; 

  if(isdone) {
    NbCouples = MaillageFF->GetArrayOfCouples().NbItems() +
      MaillageFR->GetArrayOfCouples().NbItems() +
	MaillageRF->GetArrayOfCouples().NbItems() +
	  MaillageRR->GetArrayOfCouples().NbItems();

    if(NbCouples > 0)
      MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(),
		   MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples());
  }
  return isdone;
}
Commit	Line	Data
b311480e	1	// Created on: 1999-03-03
	2	// Created by: Fabrice SERVANT
	3	// Copyright (c) 1999-1999 Matra Datavision
973c2be1	4	// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e	5	//
973c2be1	6	// This file is part of Open CASCADE Technology software library.
b311480e	7	//
d5f74e42	8	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	9	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	10	// by the Free Software Foundation, with special exception defined in the file
	11	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	12	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	13	//
973c2be1	14	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	15	// commercial license or contractual agreement.
7fd59977	16
	17	// modified by Edward AGAPOV (eap) Tue Jan 22 12:29:55 2002 (occ53)
	18	// Modified by skv - Thu Sep 25 18:24:29 2003 OCC567
	19
	20	#include <IntPolyh_Intersection.ixx>
	21	#include <IntPolyh_SectionLine.hxx>
	22	#include <IntPolyh_StartPoint.hxx>
	23	#include <IntPolyh_MaillageAffinage.hxx>
	24	#include <IntPolyh_Couple.hxx>
d642ddf5	25	#include <IntPolyh_Triangle.hxx>
7fd59977	26
7fd59977	27	Standard_Integer MYDISPLAY = 0;
	28	Standard_Integer MYPRINT = 0;
	29
7fd59977	30	IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
	31	const Handle(Adaptor3d_HSurface)& S2)
	32	{
	33	myNbSU1 = -1;
	34	myNbSV1 = -1;
	35	myNbSU2 = -1;
	36	myNbSV2 = -1;
	37	mySurf1 = S1;
	38	mySurf2 = S2;
	39	done = Standard_False;
	40	TSectionLines.Init(1000);
	41	TTangentZones.Init(10000);
	42	Perform();
	43	}
	44
	45	IntPolyh_Intersection::IntPolyh_Intersection(const Handle(Adaptor3d_HSurface)& S1,
	46	const Standard_Integer NbSU1,
	47	const Standard_Integer NbSV1,
	48	const Handle(Adaptor3d_HSurface)& S2,
	49	const Standard_Integer NbSU2,
	50	const Standard_Integer NbSV2)
	51	{
	52	myNbSU1 = NbSU1;
	53	myNbSV1 = NbSV1;
	54	myNbSU2 = NbSU2;
	55	myNbSV2 = NbSV2;
	56	mySurf1 = S1;
	57	mySurf2 = S2;
	58	done = Standard_False;
	59	TSectionLines.Init(1000);
	60	TTangentZones.Init(10000);
	61	Perform();
	62	}
	63
	64	void IntPolyh_Intersection::Perform() {
	65
	66	done = Standard_True;
	67
	68	Standard_Boolean startFromAdvanced = Standard_False;
	69	Standard_Boolean isStdDone = Standard_False;
	70	Standard_Boolean isAdvDone = Standard_False;
	71	Standard_Integer nbCouplesStd = 0;
	72	Standard_Integer nbCouplesAdv = 0;
	73
6e6cd5d9	74	//GeomAbs_SurfaceType ST1 = mySurf1->GetType();
6e6cd5d9	75	//GeomAbs_SurfaceType ST2 = mySurf2->GetType();
7fd59977	76
	77	// if(ST1 == GeomAbs_Torus \|\| ST2 == GeomAbs_Torus)
	78	// startFromAdvanced = Standard_True;
	79
	80	IntPolyh_PMaillageAffinage aPMaillageStd = 0;
	81	IntPolyh_PMaillageAffinage aPMaillageFF = 0;
	82	IntPolyh_PMaillageAffinage aPMaillageFR = 0;
	83	IntPolyh_PMaillageAffinage aPMaillageRF = 0;
	84	IntPolyh_PMaillageAffinage aPMaillageRR = 0;
	85
	86
	87	if(!startFromAdvanced) {
	88
	89	isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
	90
	91	// default interference done well, use it
	92	if(isStdDone && nbCouplesStd > 10) {
	93	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
	94	}
	95	// default interference done, but too few interferences foud;
	96	// use advanced interference
	97	else if(isStdDone && nbCouplesStd <= 10) {
	98	isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
	99
	100	// advanced interference found
	101	if(isAdvDone && nbCouplesAdv > 10) {
	102	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
	103	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
	104	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
	105	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
	106	}
	107	else {
	108	// use result of default
	109	if(nbCouplesStd > 0)
	110	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
	111	}
	112	}
	113	// default interference faild, use advanced
	114	else {
	115	// isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
	116
	117	// if(isAdvDone && nbCouplesAdv > 0) {cout << "4adv done, nbc: " << nbCouplesAdv << endl;
	118	// aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
	119	// aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
	120	// aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
	121	// aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
	122	// }
	123	}
	124	}// start from default
	125	else {
	126
	127	isAdvDone = PerformAdv(aPMaillageFF,aPMaillageFR,aPMaillageRF,aPMaillageRR,nbCouplesAdv);
	128
	129	// advanced done, interference found; use it
	130	if(isAdvDone) {
	131
	132	if(nbCouplesAdv > 0) {
	133	aPMaillageFF->StartPointsChain(TSectionLines,TTangentZones);
	134	aPMaillageFR->StartPointsChain(TSectionLines,TTangentZones);
	135	aPMaillageRF->StartPointsChain(TSectionLines,TTangentZones);
	136	aPMaillageRR->StartPointsChain(TSectionLines,TTangentZones);
	137	}
	138	else {
	139	isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
140	if(isStdDone && nbCouplesStd > 0)
141	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
142	}
143	}
144	else {
145	isStdDone = PerformStd(aPMaillageStd,nbCouplesStd);
146	if(isStdDone && nbCouplesStd > 0)
147	aPMaillageStd->StartPointsChain(TSectionLines, TTangentZones);
148	}
149	} // start from advanced
150
151	// accept result
d642ddf5	152	nbsectionlines = TSectionLines.NbItems();
d642ddf5	153	nbtangentzones = TTangentZones.NbItems();
7fd59977	154
	155	// clean up
	156	if(aPMaillageStd) delete aPMaillageStd;
	157	if(aPMaillageFF) delete aPMaillageFF;
	158	if(aPMaillageFR) delete aPMaillageFR;
	159	if(aPMaillageRF) delete aPMaillageRF;
	160	if(aPMaillageRR) delete aPMaillageRR;
	161
	162	// verify
	163	if(!isStdDone && !isAdvDone)
	164	done = Standard_False;
	165	}
	166
	167
	168	Standard_Boolean IntPolyh_Intersection::IsDone() const {
	169	return(done);
	170	}
	171
	172
	173	Standard_Integer IntPolyh_Intersection::NbSectionLines() const {
	174	return(nbsectionlines);
	175	}
	176
	177
	178	Standard_Integer IntPolyh_Intersection::NbPointsInLine(const Standard_Integer IndexLine) const {
	179
	180	return(TSectionLines[IndexLine-1].NbStartPoints());
	181	}
	182
	183
35e08fe8	184	Standard_Integer IntPolyh_Intersection::NbPointsInTangentZone(const Standard_Integer) const {
7fd59977	185	//-- IndexLine--; (pas implemente) Attention : Tableaux de 0 a n-1
	186	// eap
	187	// return(TTangentZones.NbTangentZones());
	188	return 1;
	189	}
	190
	191
	192	Standard_Integer IntPolyh_Intersection::NbTangentZones() const {
	193	return(nbtangentzones);
	194	}
	195
	196
	197	void IntPolyh_Intersection::GetLinePoint(const Standard_Integer Indexl,
	198	const Standard_Integer Indexp,
	199	Standard_Real &x,
	200	Standard_Real &y,
	201	Standard_Real &z,
	202	Standard_Real &u1,
	203	Standard_Real &v1,
	204	Standard_Real &u2,
	205	Standard_Real &v2,
	206	Standard_Real &incidence) const {
	207	const IntPolyh_SectionLine &msl=TSectionLines[Indexl-1];
	208	const IntPolyh_StartPoint &sp=msl[Indexp-1];
	209	x=sp.X();
	210	y=sp.Y();
	211	z=sp.Z();
	212	u1=sp.U1();
	213	v1=sp.V1();
	214	u2=sp.U2();
	215	v2=sp.V2();
	216	incidence=sp.GetAngle();
	217	}
	218
	219
	220	void IntPolyh_Intersection::GetTangentZonePoint(const Standard_Integer Indexz,
35e08fe8	221	const Standard_Integer /Indexp/,
7fd59977	222	Standard_Real &x,
	223	Standard_Real &y,
	224	Standard_Real &z,
	225	Standard_Real &u1,
	226	Standard_Real &v1,
	227	Standard_Real &u2,
	228	Standard_Real &v2) const {
	229	//-- Indexz--; tableaux C
	230	// eap
	231	//const IntPolyh_StartPoint &sp=TTangentZones[Indexp-1];
	232	const IntPolyh_StartPoint &sp=TTangentZones[Indexz-1];
	233	x=sp.X();
	234	y=sp.Y();
	235	z=sp.Y();
	236	u1=sp.U1();
	237	v1=sp.V1();
	238	u2=sp.U2();
	239	v2=sp.V2();
	240	}
	241
	242	// Modified by skv - Thu Sep 25 18:07:41 2003 OCC567 Begin
	243	//=======================================================================
	244	//function : PerformMaillage
	245	//purpose : Computes MaillageAffinage
	246	//=======================================================================
	247	Standard_Boolean IntPolyh_Intersection::PerformMaillage
	248	(const Standard_Boolean isFirstFwd,
	249	const Standard_Boolean isSecondFwd,
	250	IntPolyh_PMaillageAffinage &theMaillageS)
	251	{
	252	if (myNbSU1 == -1)
	253	theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, mySurf2, MYPRINT);
	254	else
	255	theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, myNbSU1, myNbSV1,
	256	mySurf2, myNbSU2, myNbSV2,
	257	MYPRINT);
	258
	259	theMaillageS->FillArrayOfPnt(1, isFirstFwd);
	260	theMaillageS->FillArrayOfPnt(2, isSecondFwd);
	261
	262
	263	Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
	264	theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
	265	xx0, yy0, zz0, xx1, yy1, zz1);
	266
	267	theMaillageS->FillArrayOfEdges(1);
	268	theMaillageS->FillArrayOfEdges(2);
	269
	270	theMaillageS->FillArrayOfTriangles(1);
	271	theMaillageS->FillArrayOfTriangles(2);
	272
	273	theMaillageS->LinkEdges2Triangles();
	274
	275	theMaillageS->TrianglesDeflectionsRefinementBSB();
	276
	277	Standard_Integer FinTTC = theMaillageS->TriangleCompare();
	278
	279	// if too many intersections, consider surfaces parallel (eap)
	280	if(FinTTC > 200 &&
d642ddf5	281	(FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbItems() \|\|
d642ddf5	282	FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbItems()) ) {
7fd59977	283	return Standard_False;
	284	}
	285
	286	return Standard_True;
	287	}
	288
	289	//=======================================================================
	290	//function : PerformMaillage
	291	//purpose : Computes MaillageAffinage
	292	//=======================================================================
	293	Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffinage &theMaillageS)
	294	{
	295	if (myNbSU1 == -1)
	296	theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, mySurf2, MYPRINT);
	297	else
	298	theMaillageS = new IntPolyh_MaillageAffinage(mySurf1, myNbSU1, myNbSV1,
	299	mySurf2, myNbSU2, myNbSV2,
	300	MYPRINT);
	301
	302	theMaillageS->FillArrayOfPnt(1);
	303	theMaillageS->FillArrayOfPnt(2);
	304
	305
	306	Standard_Real xx0,yy0,zz0,xx1,yy1,zz1;
	307	theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
	308	xx0, yy0, zz0, xx1, yy1, zz1);
	309
	310	theMaillageS->FillArrayOfEdges(1);
	311	theMaillageS->FillArrayOfEdges(2);
	312
	313	theMaillageS->FillArrayOfTriangles(1);
	314	theMaillageS->FillArrayOfTriangles(2);
	315
	316	theMaillageS->LinkEdges2Triangles();
	317
	318	theMaillageS->TrianglesDeflectionsRefinementBSB();
	319
	320	Standard_Integer FinTTC = theMaillageS->TriangleCompare();
	321
	322	if( FinTTC == 0 ) {
	323	Standard_Boolean myZone = Standard_True;
	324	theMaillageS->SetEnlargeZone( myZone );
	325	theMaillageS->FillArrayOfPnt(1);
	326	theMaillageS->FillArrayOfPnt(2);
	327	theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2),
	328	xx0, yy0, zz0, xx1, yy1, zz1);
	329	theMaillageS->FillArrayOfEdges(1);
	330	theMaillageS->FillArrayOfEdges(2);
	331	theMaillageS->FillArrayOfTriangles(1);
	332	theMaillageS->FillArrayOfTriangles(2);
	333	theMaillageS->LinkEdges2Triangles();
	334	theMaillageS->TrianglesDeflectionsRefinementBSB();
	335	FinTTC = theMaillageS->TriangleCompare();
	336	myZone = Standard_False;
	337	theMaillageS->SetEnlargeZone( myZone );
	338	}
	339
3d063ba6	340	/*
7fd59977	341	// if too many intersections, consider surfaces parallel (eap)
	342	if(FinTTC > 200 &&
	343	(FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() \|\|
	344	FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) {
	345	return Standard_False;
	346	}
3d063ba6	347	*/
3d063ba6	348
7fd59977	349	return Standard_True;
	350	}
	351
	352	//=======================================================================
	353	//function : MergeCouples
	354	//purpose : This method analyzes arrays to find same couples. If some
	355	// are detected it leaves the couple in only one array
	356	// deleting from others.
	357	//=======================================================================
	358
	359	void IntPolyh_Intersection::MergeCouples
	360	(IntPolyh_ArrayOfCouples &anArrayFF,
	361	IntPolyh_ArrayOfCouples &anArrayFR,
	362	IntPolyh_ArrayOfCouples &anArrayRF,
	363	IntPolyh_ArrayOfCouples &anArrayRR) const
	364	{
	365	// Step 1: Sorting arrays.
	366	IntPolyh_ArrayOfCouples *anArrays[4];
	367	Standard_Integer aNbCouples[4];
	368	Standard_Integer i;
	369	IntPolyh_ArrayOfCouples *aTmpPtr;
	370	Standard_Integer aTmpNbr;
	371
	372	anArrays[0] = &anArrayFF;
	373	anArrays[1] = &anArrayFR;
	374	anArrays[2] = &anArrayRF;
	375	anArrays[3] = &anArrayRR;
	376
	377	for (i = 0; i < 4; i++)
d642ddf5	378	aNbCouples[i] = anArrays[i]->NbItems();
7fd59977	379
	380	Standard_Boolean isChanged = Standard_True;
	381
	382	while (isChanged) {
	383	isChanged = Standard_False;
	384
	385	for (i = 0; i < 3; i++) {
	386	if (aNbCouples[i] < aNbCouples[i + 1]) {
	387	aTmpPtr = anArrays[i];
	388	anArrays[i] = anArrays[i + 1];
	389	anArrays[i + 1] = aTmpPtr;
	390	aTmpNbr = aNbCouples[i];
	391	aNbCouples[i] = aNbCouples[i + 1];
	392	aNbCouples[i + 1] = aTmpNbr;
	393	isChanged = Standard_True;
	394	}
	395	}
	396	}
	397
	398	// Step 2: Searching for same couples.
	399	Standard_Integer j;
	400	Standard_Integer indC1;
	401	Standard_Integer indC2;
	402
	403	for (i = 0; i < 3; i++) {
	404	for (j = i + 1; j < 4; j++) {
	405	for (indC1 = 1; indC1 <= aNbCouples[i]; indC1++) {
	406	IntPolyh_Couple &aCouple1 = anArrays[i]->ChangeValue(indC1);
	407
	408	if (aCouple1.AnalyseFlagValue() == 1)
	409	continue;
	410
	411	for (indC2 = 1; indC2 <= aNbCouples[j]; indC2++) {
	412	IntPolyh_Couple &aCouple2 = anArrays[j]->ChangeValue(indC2);
	413
	414	if (aCouple2.AnalyseFlagValue() == 1)
	415	continue;
	416
	417	if (aCouple1.FirstValue() == aCouple2.FirstValue() &&
	418	aCouple1.SecondValue() == aCouple2.SecondValue()) {
	419	aCouple2.SetAnalyseFlag(1);
	420	}
	421	}
	422	}
	423	}
	424	}
	425	}
	426	// Modified by skv - Thu Sep 25 18:07:42 2003 OCC567 End
	427
	428	Standard_Boolean IntPolyh_Intersection::PerformStd(IntPolyh_PMaillageAffinage& MaillageS,
	429	Standard_Integer& NbCouples)
	430	{
	431	Standard_Boolean isdone = PerformMaillage(MaillageS);
d642ddf5	432	NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbItems()) : 0;
7fd59977	433	return isdone;
	434	}
	435
	436	Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& MaillageFF,
	437	IntPolyh_PMaillageAffinage& MaillageFR,
	438	IntPolyh_PMaillageAffinage& MaillageRF,
	439	IntPolyh_PMaillageAffinage& MaillageRR,
	440	Standard_Integer& NbCouples)
	441	{
	442	Standard_Boolean isdone = Standard_True;
	443	NbCouples = 0;
	444
	445	if(!PerformMaillage(Standard_True,Standard_False,MaillageFR) \|\|
	446	!PerformMaillage(Standard_False,Standard_True,MaillageRF) \|\|
	447	!PerformMaillage(Standard_True,Standard_True,MaillageFF) \|\|
	448	!PerformMaillage(Standard_False,Standard_False,MaillageRR) )
	449	isdone = Standard_False;
	450
	451	if(isdone) {
d642ddf5	452	NbCouples = MaillageFF->GetArrayOfCouples().NbItems() +
	453	MaillageFR->GetArrayOfCouples().NbItems() +
	454	MaillageRF->GetArrayOfCouples().NbItems() +
	455	MaillageRR->GetArrayOfCouples().NbItems();
7fd59977	456
	457	if(NbCouples > 0)
	458	MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(),
	459	MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples());
	460	}
	461	return isdone;
	462	}