//---------------------------------------------------------------------------- // 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) ; }