//---------------------------------------------------------------------------- // 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" //---------------------------------------------------------------------------- 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 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 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 EgtGetMinDistPointCurve( const double ptP[3], int nId, double* pdDist) { return ( ExeGetMinDistPointCurve( ptP, nId, pdDist) ? 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 EgtCurveArcRadius( int nId, double* pdRad) { return ( ExeCurveArcRadius( nId, pdRad) ? TRUE : FALSE) ; } //---------------------------------------------------------------------------- BOOL __stdcall EgtCurveArcNormVersor( int nId, int nRefId, double vtNorm[3]) { // recupero il vettore normale Vector3d vtTmp ; if ( ! ExeCurveArcNormVersor( 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 ; } //---------------------------------------------------------------------------- int __stdcall EgtSurfTmFacetNbr( int nId) { return ExeSurfTmFacetNbr( 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 EgtExtTextNormVersor( int nId, int nRefId, double vtNorm[3]) { // recupero il vettore normale Vector3d vtTmp ; if ( ! ExeExtTextNormVersor( nId, nRefId, vtTmp)) return FALSE ; // lo assegno VEC_FROM_3D( vtNorm, vtTmp) return 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 ; }