//---------------------------------------------------------------------------- // EgalTech 2020-2022 //---------------------------------------------------------------------------- // File : EXE_GeoSnap.cpp Data : 11.04.22 Versione : 2.4d1 // Contenuto : Funzioni di interrogazione di curve del DBG per EXE. // // // // Modifiche : 23.03.20 DS Creazione modulo. // // //---------------------------------------------------------------------------- //--------------------------- Include ---------------------------------------- #include "stdafx.h" #include "EXE.h" #include "EXE_Const.h" #include "EXE_Macro.h" #include "AuxTools.h" #include "GeoTools.h" #include "/EgtDev/Include/EgtNumUtils.h" #include "/EgtDev/Include/EXeExecutor.h" #include "/EgtDev/Include/EXeConst.h" #include "/EgtDev/Include/EGkGeoPoint3d.h" #include "/EgtDev/Include/EGkGeoPoint3d.h" #include "/EgtDev/Include/EGkCurve.h" #include "/EgtDev/Include/EGkCurveArc.h" #include "/EgtDev/Include/EGkCurveBezier.h" #include "/EgtDev/Include/EGkCurveComposite.h" #include "/EgtDev/Include/EGkCurveAux.h" #include "/EgtDev/Include/EGkDistPointCurve.h" #include "/EgtDev/Include/EGkIntersCurves.h" #include "/EgtDev/Include/EGkSurfFlatRegion.h" using namespace std ; //---------------------------------------------------------------------------- bool ExeCurveDomain( int nId, double* pdStart, double* pdEnd) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico i parametri if ( pdStart == nullptr || pdEnd == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // recupero il dominio return ( pCurve != nullptr && pCurve->GetDomain( *pdStart, *pdEnd)) ; } //---------------------------------------------------------------------------- bool ExeCurveLength( int nId, double* pdLen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdLen == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // recupero la lunghezza return ( pCurve != nullptr && pCurve->GetLength( *pdLen)) ; } //---------------------------------------------------------------------------- bool ExeCurveLengthAtParam( int nId, double dPar, double* pdLen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdLen == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // recupero la lunghezza return ( pCurve != nullptr && pCurve->GetLengthAtParam( dPar, *pdLen)) ; } //---------------------------------------------------------------------------- bool ExeCurveParamAtLength( int nId, double dLen, double* pdPar) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdPar == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // recupero il parametro in corrispondenza dLen return ( pCurve != nullptr && pCurve->GetParamAtLength( dLen, *pdPar)) ; } //---------------------------------------------------------------------------- bool ExeCurveParamAtPoint( int nId, const Point3d& ptP, double dTol, int nRefType, double* pdPar) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdPar == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; bool bOk = ( pCurve != nullptr) ; // recupero il riferimento locale Frame3d frLoc ; bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ; // porto il punto in locale Point3d ptL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ; // recupero il parametro in corrispondenza ptL return ( bOk && pCurve->GetParamAtPoint( ptL, *pdPar, dTol)) ; } //---------------------------------------------------------------------------- bool ExeCurveLengthAtPoint( int nId, const Point3d& ptOn, double dExtend, double* pdLen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdLen == nullptr) return false ; // recupero la curva const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; if ( pCurve == nullptr) return false ; // determino la posizione parametrica del punto sulla curva (con tolleranza) int nFlag ; double dU ; if ( ! DistPointCurve( ptOn, *pCurve).GetParamAtMinDistPoint( 0, dU, nFlag) || nFlag != MDPCI_NORMAL) return false ; // se non richiesta estensione o punto interno alla curva, recupero la lunghezza alla posizione parametrica if ( dExtend < EPS_SMALL || ( ! pCurve->IsStartParam( dU) && ! pCurve->IsEndParam( dU))) return ( pCurve->GetLengthAtParam( dU, *pdLen) ? true : false) ; // allungo la curva dalla parte del punto PtrOwner pCopy( pCurve->Clone()) ; if ( IsNull( pCopy)) return false ; double dDeltaIni ; if ( pCopy->IsStartParam( dU)) { pCopy->ExtendStartByLen( dExtend) ; dDeltaIni = dExtend ; } else { pCopy->ExtendEndByLen( dExtend) ; dDeltaIni = 0 ; } if ( ! DistPointCurve( ptOn, *pCopy).GetParamAtMinDistPoint( 0, dU, nFlag) || nFlag != MDPCI_NORMAL) return false ; if ( pCopy->GetLengthAtParam( dU, *pdLen)) { *pdLen -= dDeltaIni ; return true ; } return false ; } //---------------------------------------------------------------------------- bool ExeCurveIsClosed( int nId) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // verifico se chiusa return ( pCurve != nullptr && pCurve->IsClosed()) ; } //---------------------------------------------------------------------------- bool ExeCurveIsFlat( int nId, Plane3d& Plane, bool bUseExtrusion, double dToler) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( &Plane == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // ne verifico la planarit� return ( pCurve != nullptr && pCurve->IsFlat( Plane, bUseExtrusion, dToler)) ; } //---------------------------------------------------------------------------- bool ExeCurveIsACircle( int nId, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW, double dToler) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico i parametri if ( &ptCen == nullptr || &vtN == nullptr || &dRad == nullptr || &bCCW == nullptr) return false ; // recupero l'oggetto IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ; if ( pGObj == nullptr) return false ; // analizzo tipi di curve candidabili switch ( pGObj->GetType()) { case CRV_ARC : { ICurveArc* pArc = GetCurveArc( pGObj) ; if ( pArc->IsACircle()) { ptCen = pArc->GetCenter() ; vtN = pArc->GetNormVersor() ; dRad = pArc->GetRadius() ; bCCW = ( pArc->GetAngCenter() > 0) ; return true ; } else return false ; } case CRV_COMPO : { ICurveComposite* pCompo = GetCurveComposite( pGObj) ; return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ; } case CRV_BEZIER : { ICurveBezier* pBezier = GetCurveBezier( pGObj) ; PolyArc PA ; if ( ! pBezier->ApproxWithArcs( dToler, ANG_TOL_STD_DEG, PA)) return false ; PtrOwner pCompo( CreateCurveComposite()) ; if ( IsNull( pCompo) || ! pCompo->FromPolyArc( PA)) return false ; return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ; } default : return false ; } return false ; } //---------------------------------------------------------------------------- bool ExeCurveIsARectangle( int nId, Point3d& ptP, Vector3d& vtL1, Vector3d& vtL2, double dToler) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico i parametri if ( &ptP == nullptr || &vtL1 == nullptr || &vtL2 == nullptr) return false ; // recupero l'oggetto IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ; if ( pGObj == nullptr) return false ; // verifico sia una curva composita if ( pGObj->GetType() != CRV_COMPO) return false ; // eseguo ICurveComposite* pCompo = GetCurveComposite( pGObj) ; return pCompo->IsARectangle( dToler, ptP, vtL1, vtL2) ; } //---------------------------------------------------------------------------- bool ExeCurveIsATrapezoid( int nId, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2, double dToler) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico i parametri if ( &ptP == nullptr || &vtB1 == nullptr || &vtL1 == nullptr || &vtB1 == nullptr) return false ; // recupero l'oggetto IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ; if ( pGObj == nullptr) return false ; // verifico sia una curva composita if ( pGObj->GetType() != CRV_COMPO) return false ; // eseguo ICurveComposite* pCompo = GetCurveComposite( pGObj) ; return pCompo->IsATrapezoid( dToler, ptP, vtB1, vtL1, vtB2) ; } //---------------------------------------------------------------------------- bool ExeCurveAreaXY( int nId, double& dArea) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( &dArea == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // determino l'area nel piano XY return ( pCurve != nullptr && pCurve->GetAreaXY( dArea)) ; } //---------------------------------------------------------------------------- bool ExeCurveArea( int nId, Plane3d& Plane, double& dArea) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico i parametri if ( &Plane == nullptr || &dArea == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // determino il piano medio della curva e la sua area su di esso (deve essere chiusa) return ( pCurve != nullptr && pCurve->GetArea( Plane, dArea)) ; } //---------------------------------------------------------------------------- bool ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // recupero quale estremo � pi� vicino al punto return ( pCurve != nullptr && pCurve->GetNearestExtremityToPoint( ptP, bStart)) ; } //---------------------------------------------------------------------------- bool ExeCurveExtrusion( int nId, int nRefId, Vector3d& vtExtr) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // ne ricavo il vettore estrusione if ( pCurve == nullptr || ! pCurve->GetExtrusion( vtExtr)) return false ; // gestione trasformazione ( eventuale) return TransformVector( pGeomDB, nId, nRefId, vtExtr) ; } //---------------------------------------------------------------------------- bool ExeCurveThickness( int nId, double* pdThick) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdThick == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; // recupero lo spessore return ( pCurve != nullptr && pCurve->GetThickness( *pdThick)) ; } //---------------------------------------------------------------------------- bool ExeCurveSelfIntersCount( int nId, int* pnCount) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pnCount == nullptr) return false ; // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; if ( pCurve == nullptr) return false ; // calcolo le auto-intersezioni SelfIntersCurve sintC( *pCurve) ; // ne recupero il numero *pnCount = sintC.GetIntersCount() ; return true ; } //---------------------------------------------------------------------------- bool ExeCurveMinAreaRectangleXY( int nId, int nRefId, Frame3d& frRect, double& dDimX, double& dDimY) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ; bool bOk = ( pCurve != nullptr) ; // recupero il riferimento della curva Frame3d frCrv ; bOk = bOk && pGeomDB->GetGlobFrame( nId, frCrv) ; // derivo la polilinea di approssimazione della curva entro la tolleranza standard PolyLine PL ; bOk = bOk && pCurve->ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, APP_LINES, PL) ; // eventuale trasformazione per riferimento di espressione if ( bOk && nRefId == GDB_ID_ROOT) PL.ToGlob( frCrv) ; else if ( bOk && nRefId == GDB_ID_GRID) PL.LocToLoc( frCrv, pGeomDB->GetGridFrame()) ; else if ( bOk && nRefId != nId) { Frame3d frDest ; // nRefId pu� essere un gruppo o una entit� if ( pGeomDB->GetGroupGlobFrame( nRefId, frDest) || pGeomDB->GetGlobFrame( nRefId, frDest)) PL.LocToLoc( frCrv, frDest) ; else bOk = false ; } // derivo il rettangolo in XY di area minima di questa Point3d ptCen ; Vector3d vtAx ; bOk = bOk && PL.GetMinAreaRectangleXY( ptCen, vtAx, dDimX, dDimY) && frRect.Set( ptCen, Z_AX, vtAx) ; return bOk ; } //---------------------------------------------------------------------------- int ExeClosedCurveClassify( int nId1, int nId2) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, 0) // recupero la prima curva const ICurve* pCrv1 = GetCurve( pGeomDB->GetGeoObj( nId1)) ; if ( pCrv1 == nullptr || ! pCrv1->IsClosed()) return CCREGC_NULL ; // recupero il riferimento della curva Frame3d frCrv1 ; if ( ! pGeomDB->GetGlobFrame( nId1, frCrv1)) return CCREGC_NULL ; // recupero la seconda curva const ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( nId2)) ; if ( pCrv2 == nullptr || ! pCrv2->IsClosed()) return CCREGC_NULL ; // recupero il riferimento della curva Frame3d frCrv2 ; if ( ! pGeomDB->GetGlobFrame( nId2, frCrv2)) return CCREGC_NULL ; // se riferimenti diversi, porto una copia della seconda nel riferimento della prima const ICurve* pCrv2L = pCrv2 ; PtrOwner pTmp ; if ( ! AreSameFrame( frCrv1, frCrv2)) { pTmp.Set( pCrv2->Clone()) ; if ( IsNull( pTmp) || ! pTmp->LocToLoc( frCrv2, frCrv1)) return CCREGC_NULL ; pCrv2L = pTmp ; } // classifico la prima curva rispetto alla seconda IntersCurveCurve ccInt( *pCrv1, *pCrv2L) ; return ccInt.GetRegionCurveClassification() ; } //---------------------------------------------------------------------------- int ExeCurveWithRegionClassify( int nCurveId, int nRegionId) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, 0) // recupero la curva e il suo riferimento const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCurveId)) ; if ( pCrv == nullptr) return CRC_NULL ; // recupero il riferimento della curva Frame3d frCrv ; if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv)) return CRC_NULL ; // recupero la superficie FlatRegion e il suo riferimento ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nRegionId)) ; if ( pSfr == nullptr) return CRC_NULL ; // recupero il riferimento della superficie Frame3d frSurf ; if ( ! pGeomDB->GetGlobFrame( nRegionId, frSurf)) return CRC_NULL ; // se riferimenti diversi, porto una copia della curva nel riferimento della superficie const ICurve* pCrvL = pCrv ; PtrOwner pTmp ; if ( ! AreSameFrame( frCrv, frSurf)) { pTmp.Set( pCrv->Clone()) ; if ( IsNull( pTmp)) return CRC_NULL ; pTmp->LocToLoc( frCrv, frSurf) ; pCrvL = pTmp ; } // classifico la curva rispetto alla regione CRVCVECTOR vcClass ; if ( ! pSfr->GetCurveClassification( *pCrvL, EPS_SMALL, vcClass)) return CRC_NULL ; int nRes = CRC_NULL ; for ( auto& cClass : vcClass) { switch ( cClass.nClass) { case CRVC_NULL : return CRC_NULL ; break ; case CRVC_IN : if ( nRes == CRC_NULL || nRes == CRC_IN || nRes == CRC_ON) nRes = CRC_IN ; else nRes = CRC_INTERS ; break ; case CRVC_OUT : if ( nRes == CRC_NULL || nRes == CRC_OUT || nRes == CRC_ON) nRes = CRC_OUT ; else nRes = CRC_INTERS ; break ; case CRVC_ON_P : case CRVC_ON_M : if ( nRes == CRC_NULL) nRes = CRC_ON ; break ; } } return nRes ; } //---------------------------------------------------------------------------- bool ExeArcRadius( int nId, double* pdRad) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdRad == nullptr) return false ; // recupero l'arco const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ; if ( pArc == nullptr) return false ; *pdRad = pArc->GetRadius() ; return true ; } //---------------------------------------------------------------------------- bool ExeArcAngCenter( int nId, double* pdAngDeg) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdAngDeg == nullptr) return false ; // recupero l'arco const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ; if ( pArc == nullptr) return false ; *pdAngDeg = pArc->GetAngCenter() ; return true ; } //---------------------------------------------------------------------------- bool ExeArcDeltaN( int nId, double* pdDeltaN) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( pdDeltaN == nullptr) return false ; // recupero l'arco const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ; if ( pArc == nullptr) return false ; *pdDeltaN = pArc->GetDeltaN() ; return true ; } //---------------------------------------------------------------------------- bool ExeArcNormVersor( int nId, int nRefId, Vector3d& vtNorm) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero l'arco const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ; if ( pArc == nullptr) return false ; // recupero la normale vtNorm = pArc->GetNormVersor() ; // gestione trasformazione ( eventuale) return TransformVector( pGeomDB, nId, nRefId, vtNorm) ; } //---------------------------------------------------------------------------- bool ExeCurveCompoLength( int nId, int nSimpCrv, double& dLen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompoCrv == nullptr) return false ; // recupero la curva semplice di indice richiesto const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ; if ( pSimpCrv == nullptr) return false ; // recupero la sua lunghezza return pSimpCrv->GetLength( dLen) ; } //---------------------------------------------------------------------------- bool ExeCurveCompoCenter( int nId, int nSimpCrv, int nRefId, Point3d& ptCen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompoCrv == nullptr) return false ; // recupero la curva semplice di indice richiesto const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ; if ( pSimpCrv == nullptr) return false ; // recupero il centro if ( ! pSimpCrv->GetCenterPoint( ptCen)) return false ; // gestione trasformazione ( eventuale) return TransformPoint( pGeomDB, nId, nRefId, ptCen) ; } //---------------------------------------------------------------------------- bool ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompoCrv == nullptr) return false ; // recupero la curva semplice di indice richiesto const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ; if ( pSimpCrv == nullptr) return false ; // a seconda del tipo di curva switch ( pSimpCrv->GetType()) { case CRV_LINE : dRad = -1 ; break ; case CRV_ARC : dRad = GetCurveArc( pSimpCrv)->GetRadius() ; break ; case CRV_BEZIER : dRad = -2 ; break ; default : dRad = -3 ; break ; } return true ; } //---------------------------------------------------------------------------- bool ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompoCrv == nullptr) return false ; // recupero la curva semplice di indice richiesto const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ; if ( pSimpCrv == nullptr) return false ; // a seconda del tipo di curva switch ( pSimpCrv->GetType()) { case CRV_LINE : dAngCen = 0 ; break ; case CRV_ARC : dAngCen = GetCurveArc( pSimpCrv)->GetAngCenter() ; break ; case CRV_BEZIER : dAngCen = 0 ; break ; default : dAngCen = 0 ; break ; } return true ; } //---------------------------------------------------------------------------- bool ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompoCrv == nullptr) return false ; // recupero la curva semplice di indice richiesto const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ; if ( pSimpCrv == nullptr) return false ; // a seconda del tipo di curva switch ( pSimpCrv->GetType()) { case CRV_LINE : vtNorm = V_NULL ; break ; case CRV_ARC : vtNorm = GetCurveArc( pSimpCrv)->GetNormVersor() ; break ; case CRV_BEZIER : vtNorm = V_NULL ; break ; default : vtNorm = V_NULL ; break ; } // gestione trasformazione ( eventuale) return TransformVector( pGeomDB, nId, nRefId, vtNorm) ; } //---------------------------------------------------------------------------- bool ExeCurveCompoGetTempProp( int nId, INTVECTOR& vProp, int nPropInd) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompo == nullptr) return false ; // recupero i valori vProp.clear() ; vProp.reserve( pCompo->GetCurveCount()) ; const ICurve* pSmplCrv = pCompo->GetFirstCurve() ; while ( pSmplCrv != nullptr) { vProp.push_back( pSmplCrv->GetTempProp( nPropInd)) ; pSmplCrv = pCompo->GetNextCurve() ; } return true ; } //---------------------------------------------------------------------------- bool ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nParamInd) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva composita const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ; if ( pCompo == nullptr) return false ; // recupero i valori vParam.clear() ; vParam.reserve( pCompo->GetCurveCount()) ; const ICurve* pSmplCrv = pCompo->GetFirstCurve() ; while ( pSmplCrv != nullptr) { vParam.push_back( pSmplCrv->GetTempParam( nParamInd)) ; pSmplCrv = pCompo->GetNextCurve() ; } return true ; } //---------------------------------------------------------------------------- int ExeShowCurveBezierControlPoints( int nCrvId, int nDestGrpId, int* pnCount) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva di Bezier IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nCrvId) ; if ( pGeoObj == nullptr || ( pGeoObj->GetType() != CRV_BEZIER && pGeoObj->GetType() != CRV_COMPO)) return GDB_ID_NULL ; // recupero il riferimento della curva Frame3d frCrv ; bool bOk = true ; bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ; // recupero il riferimento di destinazione Frame3d frDest ; bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ; if ( ! bOk) return GDB_ID_NULL ; int nType = pGeoObj->GetType() ; if ( nType == CRV_COMPO) { const ICurveComposite* pCrvCompo = GetCurveComposite( pGeoObj) ; if ( pCrvCompo == nullptr) return false ; int nFirstId = -1 ; int nCount = 0 ; for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++i) { const ICurveBezier* pCrvBezier = GetCurveBezier( pCrvCompo->GetCurve(i)) ; if ( pCrvBezier == nullptr) { if ( pnCount != nullptr) *pnCount = nCount ; return nFirstId ; } int nDeg = pCrvBezier->GetDegree() ; //bool bRat = pCrvBezier->IsRational() ; for ( int i = 0 ; i < nDeg + 1 ; ++i) { IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ; //if ( ! bRat) // pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ; //else // pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ; pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ; pGeoPt->LocToLoc( frCrv, frDest) ; int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ; if ( nFirstId == GDB_ID_NULL) nFirstId = nId ; if ( nId != GDB_ID_NULL) ++nCount ; } } // restituisco i risultati if ( pnCount != nullptr) *pnCount = nCount ; return nFirstId ; } else if ( nType == CRV_BEZIER) { const ICurveBezier* pCrvBezier = GetCurveBezier( pGeoObj) ; if ( pCrvBezier == nullptr) return false ; int nDeg = pCrvBezier->GetDegree() ; //bool bRat = pCrvBezier->IsRational() ; int nFirstId = -1 ; int nCount = 0 ; for ( int i = 0 ; i < nDeg + 1 ; ++i) { IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ; //if ( ! bRat) // pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ; //else // pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ; pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ; pGeoPt->LocToLoc( frCrv, frDest) ; int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ; if ( nFirstId == GDB_ID_NULL) nFirstId = nId ; if ( nId != GDB_ID_NULL) ++nCount ; } // restituisco i risultati if ( pnCount != nullptr) *pnCount = nCount ; return nFirstId ; } else return GDB_ID_NULL ; } //---------------------------------------------------------------------------- bool ExeCurveMaxOffset( int nId, double& dMaxOffset) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // verifico il parametro if ( &dMaxOffset == nullptr) return false ; // recupero la curva const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ; if ( pCrv == nullptr) return false ; return CalcCurveLimitOffset( *pCrv, dMaxOffset) ; } //---------------------------------------------------------------------------- int ExeCopyCompoSubCurve( int nCrvId, int nSubCrvToCopy, int nDestGrpId) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva compo const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nCrvId)) ; if ( pCompo == nullptr) return GDB_ID_NULL ; // recupero il riferimento della curva Frame3d frCrv ; bool bOk = true ; bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ; // recupero il riferimento di destinazione Frame3d frDest ; bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ; if ( ! bOk) return GDB_ID_NULL ; // creo una copia e la porto nel frame della destinazione const ICurve* pSubCrv = pCompo->GetCurve( nSubCrvToCopy) ; if ( pSubCrv == nullptr) return GDB_ID_NULL ; ICurve* pSubCrvCopy = pSubCrv->Clone() ; if ( pSubCrvCopy == nullptr) return GDB_ID_NULL ; pSubCrvCopy->LocToLoc( frCrv, frDest) ; int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ; ExeSetModified() ; // se richiesto, salvo il comando Lua equivalente if ( IsCmdLog()) { string sLua = "EgtCopyCompoSubCurve(" + IdToString( nCrvId) + "," + ToString( nSubCrvToCopy) + "," + IdToString( nDestGrpId) + ")" + " -- Id=" + ToString( nSubCrvId) ; LOG_INFO( GetCmdLogger(), sLua.c_str()) ; } // restituisco l'identificativo della nuova entità return nSubCrvId ; } //---------------------------------------------------------------------------- int ExeCopyParamRange( int nCrvId, double dUStart, double dUEnd, int nDestGrpId) { IGeomDB* pGeomDB = GetCurrGeomDB() ; VERIFY_GEOMDB( pGeomDB, false) // recupero la curva const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ; // recupero il riferimento della curva Frame3d frCrv ; bool bOk = true ; bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ; // recupero il riferimento di destinazione Frame3d frDest ; bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ; if ( ! bOk) return GDB_ID_NULL ; // creo una copia e la porto nel frame della destinazione ICurve* pSubCrvCopy = pCrv->CopyParamRange( dUStart, dUEnd) ; if ( pSubCrvCopy == nullptr) return GDB_ID_NULL ; pSubCrvCopy->LocToLoc( frCrv, frDest) ; int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ; ExeSetModified() ; return nSubCrvId ; }