//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_GdbObjects.cpp       Data : 17.10.14        Versione : 1.5i5
// Contenuto : Funzioni geometriche di base per API.
//
//
//
// Modifiche : 17.10.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EGkFrame3d.h"
#include "/EgtDev/Include/EGkBBox3d.h"

using namespace std ;

//-----------------------------------------------------------------------------
//                        Vector3d
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorNormalize( double* pdX, double* pdY, double* pdZ,
                              double dEps)
{
  // verifico i parametri
   if ( pdX == nullptr  ||  pdY == nullptr  ||  pdZ == nullptr)
      return FALSE ;
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.Normalize( dEps))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}                              

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorRotate( double* pdX, double* pdY, double* pdZ,
                           const double vtAx[3], double dAngRotDeg)
{
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.Rotate( vtAx, dAngRotDeg))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorScale( double* pdX, double* pdY, double* pdZ,
                          const double ptOrig[3], const double vtX[3], const double vtY[3], const double vtZ[3],
                          double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // costruisco il frame
   Frame3d frRef ;
   if ( ! frRef.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorMirror( double* pdX, double* pdY, double* pdZ,
                           const double vtNorm[3])
{
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.Mirror( vtNorm))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorShear( double* pdX, double* pdY, double* pdZ,
                          const double vtNorm[3], const double vtDir[3], double dCoeff)
{
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.Shear( vtNorm, vtDir, dCoeff))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorToGlob( double* pdX, double* pdY, double* pdZ,
                           const double ptOrig[3], const double vtX[3], const double vtY[3], const double vtZ[3])
{
  // costruisco il frame
   Frame3d frRef ;
   if ( ! frRef.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.ToGlob( frRef))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorToLoc( double* pdX, double* pdY, double* pdZ,
                          const double ptOrig[3], const double vtX[3], const double vtY[3], const double vtZ[3])
{
  // costruisco il frame
   Frame3d frRef ;
   if ( ! frRef.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.ToLoc( frRef))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtVectorLocToLoc( double* pdX, double* pdY, double* pdZ,
                             const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3],
                             const double ptO2[3], const double vtX2[3], const double vtY2[3], const double vtZ2[3])
{
  // costruisco il frame sorgente
   Frame3d frSou ;
   if ( ! frSou.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // costruisco il frame destinazione
   Frame3d frDest ;
   if ( ! frDest.Set( ptO2, vtX2, vtY2, vtZ2))
      return FALSE ;
  // eseguo la trasformazione
   Vector3d vtTemp( *pdX, *pdY, *pdZ) ;
   if ( ! vtTemp.LocToLoc( frSou, frDest))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = vtTemp.x ;
   *pdY = vtTemp.y ;
   *pdZ = vtTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtGetVectorRotation( const double vtS[3], const double vtE[3], const double vtAx[3],
                                double* pdAngRotDeg, BOOL* pbDet)
{
   Vector3d vtSou( vtS) ;
   bool bDet ;
   bool bOk = vtSou.GetRotation( vtE, vtAx, *pdAngRotDeg, bDet) ;
   *pbDet = ( bDet ? TRUE : FALSE) ;
   return ( bOk ? TRUE : FALSE) ;
}


//-----------------------------------------------------------------------------
//                        Point3d
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointTranslate( double* pdX, double* pdY, double* pdZ,
                             const double vtMove[3])
{                     
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   ptTemp.Translate( vtMove) ;
  // aggiorno il parametro vettore
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointRotate( double* pdX, double* pdY, double* pdZ,
                          const double ptAx[3], const double vtAx[3], double dAngRotDeg)
{
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.Rotate( ptAx, vtAx, dAngRotDeg))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointScale( double* pdX, double* pdY, double* pdZ,
                         const double ptOrig[3], const double vtX[3], const double vtY[3], const double vtZ[3],
                         double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // costruisco il frame
   Frame3d frRef ;
   if ( ! frRef.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointMirror( double* pdX, double* pdY, double* pdZ,
                          const double ptOn[3], const double vtNorm[3])
{
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.Mirror( ptOn, vtNorm))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointShear( double* pdX, double* pdY, double* pdZ,
                         const double ptOn[3], const double vtNorm[3], const double vtDir[3], double dCoeff)
{
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.Shear( ptOn, vtNorm, vtDir, dCoeff))
      return FALSE ;
  // aggiorno il parametro vettore
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointToGlob( double* pdX, double* pdY, double* pdZ,
                          const double ptOrig[3], const double vtX[3], const double vtY[3], const double vtZ[3])
{
  // costruisco il frame
   Frame3d frRef ;
   if ( ! frRef.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.ToGlob( frRef))
      return FALSE ;
  // aggiorno il parametro punto
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointToLoc( double* pdX, double* pdY, double* pdZ,
                         const double ptOrig[3], const double vtX[3], const double vtY[3], const double vtZ[3])
{
  // costruisco il frame
   Frame3d frRef ;
   if ( ! frRef.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.ToLoc( frRef))
      return FALSE ;
  // aggiorno il parametro punto
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtPointLocToLoc( double* pdX, double* pdY, double* pdZ,
                            const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3],
                            const double ptO2[3], const double vtX2[3], const double vtY2[3], const double vtZ2[3])
{
  // costruisco il frame sorgente
   Frame3d frSou ;
   if ( ! frSou.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // costruisco il frame destinazione
   Frame3d frDest ;
   if ( ! frDest.Set( ptO2, vtX2, vtY2, vtZ2))
      return FALSE ;
  // eseguo la trasformazione
   Point3d ptTemp( *pdX, *pdY, *pdZ) ;
   if ( ! ptTemp.LocToLoc( frSou, frDest))
      return FALSE ;
  // aggiorno il parametro punto
   *pdX = ptTemp.x ;
   *pdY = ptTemp.y ;
   *pdZ = ptTemp.z ;
   return TRUE ;
}

//-----------------------------------------------------------------------------
//                        Frame3d
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameFrom3Points( double ptO[3], double ptOnX[3], double ptNearY[3],
                               double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3])
{
  // calcolo il riferimento
   Frame3d frTemp ;
   if ( ! frTemp.Set( Point3d( ptO), Point3d( ptOnX), Point3d( ptNearY)))
      return FALSE ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameOCS( double ptO[3], double vtDirZ[3],
                       double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3])
{
  // calcolo il riferimento
   Frame3d frTemp ;
   if ( ! frTemp.Set( Point3d( ptO), Vector3d( vtDirZ)))
      return FALSE ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtFrameGetType( const double ptOrig[3],
                           const double vtX[3], const double vtY[3], const double vtZ[3])
{
  // costruisco il riferimento
   Frame3d frTemp ;
   frTemp.Set( ptOrig, vtX, vtY, vtZ) ;
  // ne ricavo il tipo
   return frTemp.GetType() ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameTranslate( double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3],
                             const double vtMove[3])
{                     
  // eseguo la trasformazione
   Frame3d frTemp ;
   frTemp.Set( ptOrig, vtX, vtY, vtZ) ;
   frTemp.Translate( vtMove) ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameRotate( double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3],
                          const double ptAx[3], const double vtAx[3], double dAngRotDeg)
{                     
  // eseguo la trasformazione
   Frame3d frTemp ;
   frTemp.Set( ptOrig, vtX, vtY, vtZ) ;
   frTemp.Rotate( ptAx, vtAx, dAngRotDeg) ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameToGlob( double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3],
                          const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3])
{
  // costruisco il frame di trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // eseguo la trasformazione
   Frame3d frTemp ;
   frTemp.Set( ptOrig, vtX, vtY, vtZ) ;
   if ( ! frTemp.ToGlob( frRef))
      return FALSE ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameToLoc( double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3],
                         const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3])
{
  // costruisco il frame di trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // eseguo la trasformazione
   Frame3d frTemp ;
   frTemp.Set( ptOrig, vtX, vtY, vtZ) ;
   if ( ! frTemp.ToLoc( frRef))
      return FALSE ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtFrameLocToLoc( double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3],
                            const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3],
                            const double ptO2[3], const double vtX2[3], const double vtY2[3], const double vtZ2[3])
{
  // costruisco il frame sorgente
   Frame3d frSou ;
   if ( ! frSou.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // costruisco il frame destinazione
   Frame3d frDest ;
   if ( ! frDest.Set( ptO2, vtX2, vtY2, vtZ2))
      return FALSE ;
  // eseguo la trasformazione
   Frame3d frTemp ;
   if ( ! frTemp.LocToLoc( frSou, frDest))
      return FALSE ;
  // aggiorno i parametri del frame
   VEC_FROM_3D( ptOrig, frTemp.Orig())
   VEC_FROM_3D( vtX, frTemp.VersX())
   VEC_FROM_3D( vtY, frTemp.VersY())
   VEC_FROM_3D( vtZ, frTemp.VersZ())
   return TRUE ;
}

//-----------------------------------------------------------------------------
//                        BBox3d
//-----------------------------------------------------------------------------
BOOL
__stdcall EgtBBoxTranslate( double ptMin[3], double ptMax[3],
                            const double vtMove[3])
{
  // eseguo la trasformazione
   BBox3d b3Temp ;
   b3Temp.Set( ptMin, ptMax) ;
   if ( ! b3Temp.Translate( vtMove))
      return FALSE ;
  // aggiorno i parametri del box
   VEC_FROM_3D( ptMin, b3Temp.GetMin())
   VEC_FROM_3D( ptMax, b3Temp.GetMax())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtBBoxRotate( double ptMin[3], double ptMax[3],
                         const double ptAx[3], const double vtAx[3], double dAngRotDeg)
{
  // eseguo la trasformazione
   BBox3d b3Temp ;
   b3Temp.Set( ptMin, ptMax) ;
   if ( ! b3Temp.Rotate( ptAx, vtAx, dAngRotDeg))
      return FALSE ;
  // aggiorno i parametri del box
   VEC_FROM_3D( ptMin, b3Temp.GetMin())
   VEC_FROM_3D( ptMax, b3Temp.GetMax())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtBBoxToGlob( double ptMin[3], double ptMax[3],
                         const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3])
{
  // costruisco il frame di trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // eseguo la trasformazione
   BBox3d b3Temp ;
   b3Temp.Set( ptMin, ptMax) ;
   if ( ! b3Temp.ToGlob( frRef))
      return FALSE ;
  // aggiorno i parametri del box
   VEC_FROM_3D( ptMin, b3Temp.GetMin())
   VEC_FROM_3D( ptMax, b3Temp.GetMax())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtBBoxToLoc( double ptMin[3], double ptMax[3],
                        const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3])
{
  // costruisco il frame di trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // eseguo la trasformazione
   BBox3d b3Temp ;
   b3Temp.Set( ptMin, ptMax) ;
   if ( ! b3Temp.ToLoc( frRef))
      return FALSE ;
  // aggiorno i parametri del box
   VEC_FROM_3D( ptMin, b3Temp.GetMin())
   VEC_FROM_3D( ptMax, b3Temp.GetMax())
   return TRUE ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtBBoxLocToLoc( double ptMin[3], double ptMax[3],
                           const double ptO1[3], const double vtX1[3], const double vtY1[3], const double vtZ1[3],
                           const double ptO2[3], const double vtX2[3], const double vtY2[3], const double vtZ2[3])
{
  // costruisco il frame sorgente
   Frame3d frSou ;
   if ( ! frSou.Set( ptO1, vtX1, vtY1, vtZ1))
      return FALSE ;
  // costruisco il frame destinazione
   Frame3d frDest ;
   if ( ! frDest.Set( ptO2, vtX2, vtY2, vtZ2))
      return FALSE ;
  // eseguo la trasformazione
   BBox3d b3Temp ;
   b3Temp.Set( ptMin, ptMax) ;
   if ( ! b3Temp.LocToLoc( frSou, frDest))
      return FALSE ;
  // aggiorno i parametri del box
   VEC_FROM_3D( ptMin, b3Temp.GetMin())
   VEC_FROM_3D( ptMax, b3Temp.GetMax())
   return TRUE ;
}