//----------------------------------------------------------------------------
//  EgalTech 2018-2018
//----------------------------------------------------------------------------
// File : IntersTriaTria.cpp       Data : 27.08.18         Versione : 1.9h3
// Contenuto : Implementazione della intersezione triangolo/triangolo.
//
//
//
// Modifiche : 27.08.18 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ProjPlane.h"
#include "IntersLineTria.h"
#include "CurveComposite.h"
#include "SurfFlatRegion.h"
#include "Triangulate.h"
#include "GeoConst.h"
#include "/EgtDev/Include/EGkIntersTriaTria.h"
#include "/EgtDev/Include/EGkIntersPlanePlane.h"
#include <array>

using namespace std ;

//----------------------------------------------------------------------------
static int IntersCoplanarTriaTria( const Triangle3d& trTria1, const Triangle3d& trTria2, TRIA3DVECTOR& vTria) ;

//----------------------------------------------------------------------------
int
IntersTriaTria( const Triangle3d& trTria1, const Triangle3d& trTria2, Point3d& ptInt, Point3d& ptInt2, TRIA3DVECTOR& vTria)
{
  // piano del secondo triangolo
   Plane3d plTria2 ;
   plTria2.Set( trTria2.GetCentroid(), trTria2.GetN()) ;
  // calcolo le distanze dei vertici del primo triangolo dal piano del secondo
   array< double, 3> vDist1 ;
   for ( int i = 0 ; i < 3 ; ++i)
      vDist1[i] = DistPointPlane( trTria1.GetP( i), plTria2) ;
  // verifico posizione del primo triangolo rispetto al piano del secondo
   int nVertPos1 = 0 ; int nVertNeg1 = 0 ;
   for ( const auto& dDist : vDist1) {
      if ( dDist > EPS_SMALL)
         ++ nVertPos1 ;
      else if ( dDist < -EPS_SMALL)
         ++ nVertNeg1 ;
   }
  // se il triangolo giace tutto da una parte del piano, nessuna intersezione
   if ( nVertPos1 == 3  ||  nVertNeg1 == 3)
      return ITTT_NO ;

  // piano del primo triangolo
   Plane3d plTria1 ;
   plTria1.Set( trTria1.GetCentroid(), trTria1.GetN()) ;
  // calcolo le distanze dei vertici del secondo triangolo dal piano del primo
   array< double, 3> vDist2 ;
   for ( int i = 0 ; i < 3 ; ++i)
      vDist2[i] = DistPointPlane( trTria2.GetP( i), plTria1) ;
  // verifico posizione del secondo triangolo rispetto al piano del primo
   int nVertPos2 = 0 ; int nVertNeg2 = 0 ;
   for ( const auto& dDist : vDist2) {
      if ( dDist > EPS_SMALL)
         ++ nVertPos2 ;
      else if ( dDist < -EPS_SMALL)
         ++ nVertNeg2 ;
   }
  // se il triangolo giace tutto da una parte del piano, nessuna intersezione
   if ( nVertPos2 == 3  ||  nVertNeg2 == 3)
      return ITTT_NO ;

  // se i triangoli sono complanari
   if ( ( nVertPos1 == 0  &&  nVertNeg1 == 0)  ||  ( nVertPos2 == 0  &&  nVertNeg2 == 0))
      return IntersCoplanarTriaTria( trTria1, trTria2, vTria) ;

  // intersezione tra i piani dei due triangoli
   Point3d ptL1 ; Vector3d vtL1 ;
   if ( IntersPlanePlane( plTria1, plTria2, ptL1, vtL1) != IPPT_YES)
      return ITTT_NO ;

  // limito la linea di intersezione con il primo triangolo
   int nRes1 = IntersCoplanarLineTria( ptL1, vtL1, 100.0, trTria1, ptInt, ptInt2, false) ;
   switch ( nRes1) {
   case ILTT_SEGM :
   case ILTT_SEGM_ON_EDGE :
      break ;
   case ILTT_VERT :
    return ( PointInTria( ptInt, trTria2) ? ITTT_VERT : ITTT_NO) ;
   default :
      return ITTT_NO ;
   }

  // il segmento calcolato va limitato col secondo triangolo
   Point3d ptL2 = ptInt ;
   Vector3d vtL2 = ptInt2 - ptInt ;
   double dLen = vtL2.Len() ;
   vtL2 /= dLen ;
   int nRes2 = IntersCoplanarLineTria( ptL2, vtL2, dLen, trTria2, ptInt, ptInt2, true) ;
   switch( nRes2) {
   case ILTT_NO : return ITTT_NO ;
   case ILTT_SEGM : return ITTT_YES ;
   case ILTT_SEGM_ON_EDGE : return ITTT_EDGE ;
   case ILTT_VERT : return ITTT_VERT ;
   case ILTT_EDGE : return ITTT_PNT ;
   default : return ITTT_NO ;
   }
}

//----------------------------------------------------------------------------
int
IntersCoplanarTriaTria( const Triangle3d& trTria1, const Triangle3d& trTria2, TRIA3DVECTOR& vTria)
{
  // creo la regione equivalente al primo triangolo
   SurfFlatRegion sfrTria1 ;
   PtrOwner<CurveComposite> pCcTria1( CreateBasicCurveComposite()) ;
   if ( IsNull( pCcTria1))
      return ITTT_NO ;
   pCcTria1->AddPoint( trTria1.GetP( 0)) ;
   pCcTria1->AddLine( trTria1.GetP( 1)) ;
   pCcTria1->AddLine( trTria1.GetP( 2)) ;
   pCcTria1->Close() ;
   if ( ! sfrTria1.AddExtLoop( Release( pCcTria1)))
      return ITTT_NO ;

  // creo la regione equivalente al secondo triangolo
   SurfFlatRegion sfrTria2 ;
   PtrOwner<CurveComposite> pCcTria2( CreateBasicCurveComposite()) ;
   if ( IsNull( pCcTria2))
      return ITTT_NO ;
   pCcTria2->AddPoint( trTria2.GetP( 0)) ;
   pCcTria2->AddLine( trTria2.GetP( 1)) ;
   pCcTria2->AddLine( trTria2.GetP( 2)) ;
   pCcTria2->Close() ;
   if ( ! sfrTria2.AddExtLoop( Release( pCcTria2)))
      return ITTT_NO ;
   if ( sfrTria1.GetNormVersor() * sfrTria2.GetNormVersor() < 0)
      sfrTria2.Invert() ;

  // calcolo l'intersezione tra le due regioni
   if ( ! sfrTria1.Intersect( sfrTria2)  ||  ! sfrTria1.IsValid())
      return ITTT_NO ;

  // recupero il contorno esterno del risultato come polilinea
   PolyLine PL ;
   if ( ! sfrTria1.ApproxLoopWithLines( 0, 0, LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_STD, PL))
      return ITTT_NO ;

  // eseguo una triangolazione del contorno chiuso
   PNTVECTOR vPnt ;
   INTVECTOR vTrVert ;
   Triangulate Tri ;
   if ( ! Tri.Make( PL, vPnt, vTrVert))
      return ITTT_NO ;
   int nTrVert = int( vTrVert.size()) / 3 ;
   for ( int i = 0 ; i < nTrVert ; ++i) {
      Triangle3d Tria ;
      Tria.Set( vPnt[vTrVert[3*i]], vPnt[vTrVert[3*i+1]], vPnt[vTrVert[3*i+2]]) ;
      if ( Tria.Validate( true))
         vTria.emplace_back( Tria) ;
   }

   return ITTT_OVERLAPS ;
}