[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 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>

#ifdef DEB
  # define MYDEBUG DEB 
#else
  # define MYDEBUG 0
#endif

Standard_Integer MYDISPLAY = 0;
Standard_Integer MYPRINT   = 0;

# if MYDEBUG
//  # include "visudebug.hxx"
# endif


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