//---------------------------------------------------------------------------- // EgalTech 2014-2014 //---------------------------------------------------------------------------- // File : API_GeoSnap.cpp Data : 02.10.14 Versione : 1.5i5 // Contenuto : Funzioni di snap ad oggetti del DB geometrico per API. // // // // Modifiche : 02.10.14 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "API.h" #include "/EgtDev/Include/EInAPI.h" #include "/EgtDev/Include/EXeExecutor.h" #include "/EgtDev/Include/EgtStringConverter.h" #include using namespace std ; //---------------------------------------------------------------------------- BOOL __stdcall EgtStartPoint( int nId, int nRefId, double ptP[3]) { // recupero il punto Point3d ptStart ; if ( ! ExeStartPoint( nId, nRefId, ptStart)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptStart) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtEndPoint( int nId, int nRefId, double ptP[3]) { // recupero il punto Point3d ptEnd ; if ( ! ExeEndPoint( nId, nRefId, ptEnd)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptEnd) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtMidPoint( int nId, int nRefId, double ptP[3]) { // recupero il punto Point3d ptMid ; if ( ! ExeMidPoint( nId, nRefId, ptMid)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptMid) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCenterPoint( int nId, int nRefId, double ptP[3]) { // recupero il punto Point3d ptCent ; if ( ! ExeCenterPoint( nId, nRefId, ptCent)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptCent) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCentroid( int nId, int nRefId, double ptP[3]) { // recupero il punto Point3d ptCent ; if ( ! ExeCentroid( nId, nRefId, ptCent)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptCent) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtAtParamPoint( int nId, double dU, int nRefId, double ptP[3]) { // recupero il punto Point3d ptAtPar ; if ( ! ExeAtParamPoint( nId, dU, nRefId, ptAtPar)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptAtPar) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtNearPoint( int nId, const double ptNear[3], int nRefId, double ptP[3]) { // recupero il punto Point3d ptInt ; if ( ! ExeNearPoint( nId, ptNear, nRefId, ptInt)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptInt) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtIntersectionPoint( int nId1, int nId2, const double ptNear[3], int nRefId, double ptP[3]) { // recupero il punto Point3d ptInt ; if ( ! ExeIntersectionPoint( nId1, nId2, ptNear, nRefId, ptInt)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptInt) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtStartVector( int nId, int nRefId, double vtV[3]) { // recupero il vettore Vector3d vtStart ; if ( ! ExeStartVector( nId, nRefId, vtStart)) return FALSE ; // ritorno il vettore VEC_FROM_3D( vtV, vtStart) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtEndVector( int nId, int nRefId, double vtV[3]) { // recupero il vettore Vector3d vtEnd ; if ( ! ExeEndVector( nId, nRefId, vtEnd)) return FALSE ; // ritorno il vettore VEC_FROM_3D( vtV, vtEnd) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtMidVector( int nId, int nRefId, double vtV[3]) { // recupero il vettore Vector3d vtMid ; if ( ! ExeMidVector( nId, nRefId, vtMid)) return FALSE ; // ritorno il vettore VEC_FROM_3D( vtV, vtMid) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtAtParamVector( int nId, double dU, int nSide, int nRefId, double vtV[3]) { // recupero il vettore Vector3d vtAtPar ; if ( ! ExeAtParamVector( nId, dU, nSide, nRefId, vtAtPar)) return FALSE ; // ritorno il vettore VEC_FROM_3D( vtV, vtAtPar) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtFrame( int nId, int nRefId, double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3]) { // recupero il frame Frame3d frFrame ; if ( ! ExeFrame( nId, nRefId, frFrame)) return FALSE ; // assegno l'origine VEC_FROM_3D( ptOrig, frFrame.Orig()) // assegno il versore X VEC_FROM_3D( vtX, frFrame.VersX()) // assegno il versore Y VEC_FROM_3D( vtY, frFrame.VersY()) // assegno il versore Z VEC_FROM_3D( vtZ, frFrame.VersZ()) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveDomain( int nId, double* pdStart, double* pdEnd) { return ( ExeCurveDomain( nId, pdStart, pdEnd) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveLength( int nId, double* pdLen) { return ( ExeCurveLength( nId, pdLen) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveLengthAtPoint( int nId, const double ptOn[3], double dExtend, double* pdLen) { return ( ExeCurveLengthAtPoint( nId, ptOn, dExtend, pdLen) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveIsClosed( int nId) { return ( ExeCurveIsClosed( nId) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveIsFlat( int nId, double vtN[3], double* pdDist) { if ( vtN == nullptr || pdDist == nullptr) return FALSE ; Plane3d Plane ; if ( ! ExeCurveIsFlat( nId, Plane)) return FALSE ; VEC_FROM_3D( vtN, Plane.GetVersN()) *pdDist = Plane.GetDist() ; return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveAreaXY( int nId, double* pdArea) { return ( ExeCurveAreaXY( nId, *pdArea) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveArea( int nId, double vtN[3], double* pdDist, double* pdArea) { if ( vtN == nullptr || pdDist == nullptr || pdArea == nullptr) return FALSE ; Plane3d Plane ; if ( ! ExeCurveArea( nId, Plane, *pdArea)) return FALSE ; VEC_FROM_3D( vtN, Plane.GetVersN()) *pdDist = Plane.GetDist() ; return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveNearestExtremityToPoint( int nId, const double ptP[3], BOOL* pbStart) { if ( pbStart == nullptr) return FALSE ; bool bStart ; if ( ! ExeCurveNearestExtremityToPoint( nId, ptP, bStart)) return FALSE ; *pbStart = ( bStart ? TRUE : FALSE) ; return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveExtrusion( int nId, int nRefId, double vtExtr[3]) { // recupero il vettore estrusione Vector3d vtTmp ; if ( ! ExeCurveExtrusion( nId, nRefId, vtTmp)) return FALSE ; // lo assegno VEC_FROM_3D( vtExtr, vtTmp) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveThickness( int nId, double* pdThick) { return ( ExeCurveThickness( nId, pdThick) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveSelfIntersCount( int nId, int* pnCount) { return ( ExeCurveSelfIntersCount( nId, pnCount) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveMinAreaRectangleXY( int nId, int nRefId, double ptOrig[3], double vtX[3], double vtY[3], double vtZ[3], double* pdDimX, double* pdDimY) { // eseguo calcoli Frame3d frRect ; double dDimX, dDimY ; if ( ! ExeCurveMinAreaRectangleXY( nId, nRefId, frRect, dDimX, dDimY)) return FALSE ; // assegno l'origine if ( ptOrig != nullptr) VEC_FROM_3D( ptOrig, frRect.Orig()) // assegno il versore X if ( vtX != nullptr) VEC_FROM_3D( vtX, frRect.VersX()) // assegno il versore Y if ( vtY != nullptr) VEC_FROM_3D( vtY, frRect.VersY()) // assegno il versore Z if ( vtZ != nullptr) VEC_FROM_3D( vtZ, frRect.VersZ()) if ( pdDimX != nullptr) *pdDimX = dDimX ; if ( pdDimY != nullptr) *pdDimY = dDimY ; return TRUE ; } //---------------------------------------------------------------------------- int __stdcall EgtClosedCurveClassify( int nId1, int nId2) { return ExeClosedCurveClassify( nId1, nId2) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtGetMinDistPointCurve( const double ptP[3], int nId, double* pdDist, double* pdU) { return ( ExeGetMinDistPointCurve( ptP, nId, pdDist, pdU) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtGetMinDistPntSidePointCurve( const double ptP[3], int nId, const double vtN[3], double* pdDist, double ptMin[3], int* pnSide) { if ( pdDist == nullptr || ptMin == nullptr || pnSide == nullptr) return FALSE ; Point3d ptTmp ; if ( ! ExeGetMinDistPntSidePointCurve( ptP, nId, vtN, pdDist, ptTmp, pnSide)) return FALSE ; VEC_FROM_3D( ptMin, ptTmp) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtArcRadius( int nId, double* pdRad) { return ( ExeArcRadius( nId, pdRad) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtArcAngCenter( int nId, double* pdAngDeg) { return ( ExeArcAngCenter( nId, pdAngDeg) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtArcDeltaN( int nId, double* pdDeltaN) { return ( ExeArcDeltaN( nId, pdDeltaN) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtArcNormVersor( int nId, int nRefId, double vtNorm[3]) { // recupero il vettore normale Vector3d vtTmp ; if ( ! ExeArcNormVersor( nId, nRefId, vtTmp)) return FALSE ; // lo assegno VEC_FROM_3D( vtNorm, vtTmp) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveCompoCenter( int nId, int nSimpCrv, int nRefId, double ptCen[3]) { // recupero il centro Point3d ptTmp ; if ( ! ExeCurveCompoCenter( nId, nSimpCrv, nRefId, ptTmp)) return FALSE ; // lo assegno VEC_FROM_3D( ptCen, ptTmp) return TRUE ; } //---------------------------------------------------------------------------- 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 ; } //---------------------------------------------------------------------------- int __stdcall EgtSurfFrChunkCount( int nId) { return ExeSurfFrChunkCount( nId) ; } //---------------------------------------------------------------------------- int __stdcall EgtSurfFrChunkSimpleClassify( int nId1, int nChunk1, int nId2, int nChunk2) { return ExeSurfFrChunkSimpleClassify( nId1, nChunk1, nId2, nChunk2) ; } //---------------------------------------------------------------------------- int __stdcall EgtSurfTmFacetCount( int nId) { return ExeSurfTmFacetCount( nId) ; } //---------------------------------------------------------------------------- int __stdcall EgtSurfTmFacetFromTria( int nId, int nT) { return ExeSurfTmFacetFromTria( nId, nT) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtSurfTmFacetNearestEndPoint( int nId, int nFacet, const double ptNear[3], int nRefId, double ptEnd[3], double vtNorm[3]) { // 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]) { // 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]) { // 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]) { // 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 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 ; vAdj = (int*) malloc( nDim * sizeof( int)) ; if ( vAdj == nullptr) return FALSE ; int nCount = 0 ; 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 Point3d ptMyP1, ptMyP2 ; if ( ! ExeSurfTmFacetsContact( nId, nF1, nF2, nRefId, *pbAdjac, ptMyP1, ptMyP2, *pdAng)) return FALSE ; // assegno risultati VEC_FROM_3D( ptP1, ptMyP1) VEC_FROM_3D( ptP2, ptMyP2) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtTextNormVersor( int nId, int nRefId, double vtNorm[3]) { // verifica parametro di ritorno if ( vtNorm == nullptr) return FALSE ; // recupero il vettore normale Vector3d vtTmp ; if ( ! ExeTextNormVersor( nId, nRefId, vtTmp)) return FALSE ; // lo assegno VEC_FROM_3D( vtNorm, vtTmp) return TRUE ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtTextGetContent( int nId, wchar_t*& wsText) { if ( &wsText == nullptr) return FALSE ; string sText ; if ( ! ExeTextGetContent( nId, sText)) return FALSE ; wsText = _wcsdup( stringtoW( sText)) ; return (( wsText == nullptr) ? FALSE : TRUE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtTextGetFont( int nId, wchar_t*& wsFont) { if ( &wsFont == nullptr) return FALSE ; string sFont ; if ( ! ExeTextGetFont( nId, sFont)) return FALSE ; wsFont = _wcsdup( stringtoW( sFont)) ; return (( wsFont == nullptr) ? FALSE : TRUE) ; } //------------------------------------------------------------------------------- BOOL __stdcall EgtPointToIdGlob( double ptP[3], int nId) { // trasformo il punto Point3d ptTmp( ptP) ; if ( ! ExePointToIdGlob( ptTmp, nId)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptTmp) return TRUE ; } //------------------------------------------------------------------------------- BOOL __stdcall EgtPointToIdLoc( double ptP[3], int nId) { // trasformo il punto Point3d ptTmp( ptP) ; if ( ! ExePointToIdLoc( ptTmp, nId)) return FALSE ; // ritorno il punto VEC_FROM_3D( ptP, ptTmp) return TRUE ; } //------------------------------------------------------------------------------- BOOL __stdcall EgtVectorToIdGlob( double vtV[3], int nId) { // trasformo il vettore Vector3d vtTmp( vtV) ; if ( ! ExeVectorToIdGlob( vtTmp, nId)) return FALSE ; // ritorno il punto VEC_FROM_3D( vtV, vtTmp) return TRUE ; } //------------------------------------------------------------------------------- BOOL __stdcall EgtVectorToIdLoc( double vtV[3], int nId) { // trasformo il vettore Vector3d vtTmp( vtV) ; if ( ! ExeVectorToIdLoc( vtTmp, nId)) return FALSE ; // ritorno il punto VEC_FROM_3D( vtV, vtTmp) return TRUE ; }