Dario Sassi
75d251f561
- aggiornata interfaccia di EgtSurfBezierParamsFromPoint - aggiunta interfaccia di EgtSurfBezierGetPointNrmD1.
385 lines
12 KiB
C++
385 lines
12 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2020-2020
|
|
//----------------------------------------------------------------------------
|
|
// File : API_GdbGetSurf.cpp Data : 30.03.20 Versione : 2.2c3
|
|
// Contenuto : Funzioni di interrogazione delle superfici per API.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 30.03.20 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "API.h"
|
|
#include "/EgtDev/Include/EInAPI.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfArea( int nId, double* pdArea)
|
|
{
|
|
if ( pdArea == nullptr)
|
|
return FALSE ;
|
|
// recupero l'area
|
|
return ( ExeSurfArea( nId, *pdArea) ? TRUE : FALSE) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfIsClosed( int nId)
|
|
{
|
|
// verifico se superficie è chiusa (definisce un volume interno)
|
|
return ( ExeSurfIsClosed( nId) ? TRUE : FALSE) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfVolume( int nId, double* pdVol)
|
|
{
|
|
if ( pdVol == nullptr)
|
|
return FALSE ;
|
|
// recupero il volume (se superficie chiusa)
|
|
return ( ExeSurfVolume( nId, *pdVol) ? TRUE : FALSE) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfFrNormVersor( int nId, int nRefId, double vtNorm[3])
|
|
{
|
|
// recupero il vettore normale
|
|
Vector3d vtTmp ;
|
|
if ( ! ExeSurfFrNormVersor( nId, nRefId, vtTmp))
|
|
return FALSE ;
|
|
// lo assegno
|
|
VEC_FROM_3D( vtNorm, vtTmp)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfFrGrossArea( int nId, double* pdArea)
|
|
{
|
|
if ( pdArea == nullptr)
|
|
return FALSE ;
|
|
// recupero l'area approssimata
|
|
return ( ExeSurfFrGrossArea( nId, *pdArea) ? TRUE : FALSE) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtSurfFrChunkCount( int nId)
|
|
{
|
|
return ExeSurfFrChunkCount( nId) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2, double dToler)
|
|
{
|
|
return ExeSurfFrChunkSimpleClassify( nId1, nChunk1, nId2, nChunk2, dToler) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfFrChunkCenter( int nId, int nChunk, int nRefId, double ptCen[3], double vtNorm[3])
|
|
{
|
|
// verifica parametri
|
|
if ( ptCen == nullptr || vtNorm == nullptr)
|
|
return FALSE ;
|
|
// recupero il centro e la normale
|
|
Point3d ptTmp ;
|
|
Vector3d vtN ;
|
|
if ( ! ExeSurfFrChunkCenter( nId, nChunk, nRefId, ptTmp, vtN))
|
|
return FALSE ;
|
|
// li assegno
|
|
VEC_FROM_3D( ptCen, ptTmp)
|
|
VEC_FROM_3D( vtNorm, vtN)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtExtractSurfFrChunkLoops( int nId, int nChunk, int nDestGrpId, int* pnCount)
|
|
{
|
|
return ExeExtractSurfFrChunkLoops( nId, nChunk, nDestGrpId, pnCount) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtSurfTmPartCount( int nId)
|
|
{
|
|
return ExeSurfTmPartCount( nId) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtSurfTmFacetCount( int nId)
|
|
{
|
|
return ExeSurfTmFacetCount( nId) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtSurfTmFacetFromTria( int nId, int nT)
|
|
{
|
|
return ExeSurfTmFacetFromTria( nId, nT) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmGetVertex( int nId, int nVert, int nRefId, double ptVert[3])
|
|
{
|
|
// verifica parametri
|
|
if ( ptVert == nullptr)
|
|
return FALSE ;
|
|
// recupero il vertice
|
|
Point3d ptV ;
|
|
if ( ! ExeSurfTmGetVertex( nId, nVert, nRefId, ptV))
|
|
return FALSE ;
|
|
// lo assegno
|
|
VEC_FROM_3D( ptVert, ptV)
|
|
return TRUE ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmGetNearestVertex( int nId, const double ptNear[3], int nRefId, int* pnVert, double ptVert[3])
|
|
{
|
|
// verifica parametri
|
|
if ( ptNear == nullptr || pnVert == nullptr || ptVert == nullptr)
|
|
return FALSE ;
|
|
// recupero indice del vertice e sue coordinate
|
|
Point3d ptTmp ;
|
|
if ( ! ExeSurfTmGetNearestVertex( nId, ptNear, nRefId, *pnVert, ptTmp))
|
|
return FALSE ;
|
|
// le assegno
|
|
VEC_FROM_3D( ptVert, ptTmp)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetNearestEndPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
|
|
double ptEnd[3], double vtNorm[3])
|
|
{
|
|
// verifica parametri
|
|
if ( ptNear == nullptr || ptEnd == nullptr || vtNorm == nullptr)
|
|
return FALSE ;
|
|
// recupero il punto e la normale
|
|
Point3d ptTmp ;
|
|
Vector3d vtN ;
|
|
if ( ! ExeSurfTmFacetNearestEndPoint( nId, nFacet, ptNear, nRefId, ptTmp, vtN))
|
|
return FALSE ;
|
|
// li assegno
|
|
VEC_FROM_3D( ptEnd, ptTmp)
|
|
VEC_FROM_3D( vtNorm, vtN)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetNearestMidPoint( int nId, int nFacet, const double ptNear[3], int nRefId,
|
|
double ptMid[3], double vtNorm[3])
|
|
{
|
|
// verifica parametri
|
|
if ( ptNear == nullptr || ptMid == nullptr || vtNorm == nullptr)
|
|
return FALSE ;
|
|
// recupero il punto e la normale
|
|
Point3d ptTmp ;
|
|
Vector3d vtN ;
|
|
if ( ! ExeSurfTmFacetNearestMidPoint( nId, nFacet, ptNear, nRefId, ptTmp, vtN))
|
|
return FALSE ;
|
|
// li assegno
|
|
VEC_FROM_3D( ptMid, ptTmp)
|
|
VEC_FROM_3D( vtNorm, vtN)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetCenter( int nId, int nFacet, int nRefId, double ptCen[3], double vtNorm[3])
|
|
{
|
|
// verifica parametri
|
|
if ( ptCen == nullptr || vtNorm == nullptr)
|
|
return FALSE ;
|
|
// recupero il centro e la normale
|
|
Point3d ptTmp ;
|
|
Vector3d vtN ;
|
|
if ( ! ExeSurfTmFacetCenter( nId, nFacet, nRefId, ptTmp, vtN))
|
|
return FALSE ;
|
|
// li assegno
|
|
VEC_FROM_3D( ptCen, ptTmp)
|
|
VEC_FROM_3D( vtNorm, vtN)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetNormVersor( int nId, int nFacet, int nRefId, double vtNorm[3])
|
|
{
|
|
// verifica parametri
|
|
if ( vtNorm == nullptr)
|
|
return FALSE ;
|
|
// recupero il vettore normale
|
|
Vector3d vtTmp ;
|
|
if ( ! ExeSurfTmFacetNormVersor( nId, nFacet, nRefId, vtTmp))
|
|
return FALSE ;
|
|
// lo assegno
|
|
VEC_FROM_3D( vtNorm, vtTmp)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetOppositeSide( int nId, int nFacet, const double vtDir[3], int nRefId,
|
|
double ptP1[3], double ptP2[3])
|
|
{
|
|
// verifica parametri
|
|
if ( vtDir == nullptr || ptP1 == nullptr || ptP2 == nullptr)
|
|
return FALSE ;
|
|
// recupero gli estremi del lato opposto
|
|
Point3d ptMyP1, ptMyP2 ;
|
|
Vector3d vtMyIn1, vtMyOut2 ;
|
|
if ( ! ExeSurfTmFacetOppositeSide( nId, nFacet, vtDir, nRefId, ptMyP1, ptMyP2))
|
|
return FALSE ;
|
|
// assegno risultati
|
|
VEC_FROM_3D( ptP1, ptMyP1)
|
|
VEC_FROM_3D( ptP2, ptMyP2)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetAdjacencies( int nId, int nFacet, int*& vAdj, int* pnCount)
|
|
{
|
|
// verifica parametri di ritorno
|
|
if ( &vAdj == nullptr || pnCount == nullptr)
|
|
return FALSE ;
|
|
// eseguo
|
|
INTMATRIX vTmp ;
|
|
if ( ! ExeSurfTmFacetAdjacencies( nId, nFacet, vTmp))
|
|
return FALSE ;
|
|
// recupero il risultato
|
|
int nDim = 0 ;
|
|
for ( int i = 0 ; i < int( vTmp.size()) ; ++ i)
|
|
nDim += int( vTmp[i].size()) + 1 ;
|
|
int nCount = 0 ;
|
|
if ( nDim == 0) {
|
|
vAdj = nullptr ;
|
|
}
|
|
else {
|
|
vAdj = (int*) malloc( nDim * sizeof( int)) ;
|
|
if ( vAdj == nullptr)
|
|
return FALSE ;
|
|
for ( int i = 0 ; i < int( vTmp.size()) ; ++ i) {
|
|
for ( int j = 0 ; j < int( vTmp[i].size()) ; ++ j) {
|
|
vAdj[nCount] = vTmp[i][j] ;
|
|
nCount ++ ;
|
|
}
|
|
vAdj[nCount] = - 2 ;
|
|
nCount ++ ;
|
|
}
|
|
}
|
|
*pnCount = nCount ;
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfTmFacetsContact( int nId, int nF1, int nF2, int nRefId,
|
|
BOOL* pbAdjac, double ptP1[3], double ptP2[3], double* pdAng)
|
|
{
|
|
// verifica parametri di ritorno
|
|
if ( pbAdjac == nullptr || ptP1 == nullptr || ptP2 == nullptr || pdAng == nullptr)
|
|
return FALSE ;
|
|
// eseguo
|
|
bool bAdjac ;
|
|
Point3d ptMyP1, ptMyP2 ;
|
|
if ( ! ExeSurfTmFacetsContact( nId, nF1, nF2, nRefId, bAdjac, ptMyP1, ptMyP2, *pdAng))
|
|
return FALSE ;
|
|
// assegno risultati
|
|
*pbAdjac = ( bAdjac ? TRUE : FALSE) ;
|
|
VEC_FROM_3D( ptP1, ptMyP1)
|
|
VEC_FROM_3D( ptP2, ptMyP2)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtGetSurfTmSilhouette( int nId, const double vtDir[3], double dToler, int nDestGrpId, int nRefType, int* pnCount)
|
|
{
|
|
return ExeGetSurfTmSilhouette( nId, vtDir, dToler, nDestGrpId, nRefType, pnCount) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtExtractSurfTmLoops( int nId, int nDestGrpId, int* pnCount)
|
|
{
|
|
return ExeExtractSurfTmLoops( nId, nDestGrpId, pnCount) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtExtractSurfTmFacetLoops( int nId, int nFacet, int nDestGrpId, int* pnCount)
|
|
{
|
|
return ExeExtractSurfTmFacetLoops( nId, nFacet, nDestGrpId, pnCount) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtExtractSurfTmTriaLoop( int nId, int nT, int nDestGrpId)
|
|
{
|
|
return ExeExtractSurfTmTriaLoop( nId, nT, nDestGrpId) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtCopySurfTmFacet( int nId, int nFacet, int nDestGrpId)
|
|
{
|
|
return ExeCopySurfTmFacet( nId, nFacet, nDestGrpId) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfBezierParamsFromPoint( int nSurfId, const double ptOnSurf[3], int nRefId, double* pdU, double* pdV)
|
|
{
|
|
// verifica parametri
|
|
if ( ptOnSurf == nullptr || pdU == nullptr || pdV == nullptr)
|
|
return FALSE ;
|
|
// eseguo
|
|
return ( ExeSurfBezierParamsFromPoint( nSurfId, ptOnSurf, nRefId, *pdU, *pdV) ? TRUE : FALSE) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
__stdcall EgtSurfBezierGetPointNrmD1( int nSurfId, double dU, double dV, int nUsd, int nVsd, int nRefId,
|
|
double ptP[3], double vtNorm[3], double vtDerU[3], double vtDerV[3])
|
|
{
|
|
// verifica parametri di ritorno
|
|
if ( ptP == nullptr || vtNorm == nullptr || vtDerU == nullptr || vtDerV == nullptr)
|
|
return FALSE ;
|
|
// eseguo
|
|
Point3d ptMyP ;
|
|
Vector3d vtMyNorm, vtMyDerU, vtMyDerV ;
|
|
if ( ! ExeSurfBezierGetPointNrmD1( nSurfId, dU, dV, nUsd, nVsd, nRefId, ptMyP, vtMyNorm, vtMyDerU, vtMyDerV))
|
|
return FALSE ;
|
|
// assegno risultati
|
|
VEC_FROM_3D( ptP, ptMyP)
|
|
VEC_FROM_3D( vtNorm, vtMyNorm)
|
|
VEC_FROM_3D( vtDerU, vtMyDerU)
|
|
VEC_FROM_3D( vtDerV, vtMyDerV)
|
|
return TRUE ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
__stdcall EgtExtractSurfBezierLoops( int nId, int nDestGrpId, int* pnCount)
|
|
{
|
|
return ExeExtractSurfBezierLoops( nId, nDestGrpId, pnCount) ;
|
|
}
|