From 8ae1d4cdc2e08303c40348d8c27bb10fe5894cad Mon Sep 17 00:00:00 2001 From: Riccardo Elitropi Date: Wed, 10 Jan 2024 18:28:17 +0100 Subject: [PATCH] EgtMachKernel : - LeadIn/Out VORONOI e Dijkstra per casi ottimizzati a Spirale. - migliorie sui percotrsi di ritorno. --- Pocketing.cpp | 270 +++++++++++++++++++++++++++++++++----------------- 1 file changed, 177 insertions(+), 93 deletions(-) diff --git a/Pocketing.cpp b/Pocketing.cpp index dc9d7bd..1beda29 100644 --- a/Pocketing.cpp +++ b/Pocketing.cpp @@ -2308,6 +2308,24 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId) for ( int s = 0 ; s < int( vSrfSliced.size()) ; ++ s) vSrfSliced[s]->ToGlob( frElevation) ; + for ( int s = 0 ; s < int( vSrfSliced.size()) ; ++ s) { + PtrOwner pSrf_toDraw( CloneSurfFlatRegion( vSrfSliced[s])) ; + int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_toDraw->Clone()) ; + m_pGeomDB->SetMaterial( a, Color( 0.0, 0.0, 1.0, 0.45)) ; + for ( int c = 0 ; c < pSrf_toDraw->GetChunkCount() ; ++ c) { + for ( int l = 0 ; l < pSrf_toDraw->GetLoopCount( c) ; ++ l) { + PtrOwner pCrvCompo( GetCurveComposite( pSrf_toDraw->GetLoop( c, l))) ; + for ( int u = 0 ; u < pCrvCompo->GetCurveCount() ; ++ u) { + int nProp0 ; pCrvCompo->GetCurveTempProp( u, nProp0, 0) ; + int nProp1 ; pCrvCompo->GetCurveTempProp( u, nProp1, 1) ; + int aaa = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompo->GetCurve( u)->Clone()) ; + m_pGeomDB->SetMaterial( aaa, nProp0 == 0 ? BLUE : RED) ; + } + } + } + } + + // riporto le curve per i casi ottimizzati nel frame globale for ( int u = 0 ; u < int( vCrvOEWithFlags.size()) ; ++ u) for ( int uu = 0 ; uu < int( vCrvOEWithFlags[u].size()) ; ++ uu) @@ -5721,21 +5739,32 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& int nStep = int( vSfr.size()) ; // determino lo step classico ( senza considerare gli step extra) double dStep = dElev / nStep ; - // Dati Spiral dello step precedente ( j-1) - Point3d ptP1, ptStartPrec ; // per LeadIn attuale e precedente - BOOLVECTOR vbMidOutPrec ; // flags per effettiva entrata precedente da fuori dal grezzo - ICRVCOMPOPOVECTOR vMCrv_step_prec ; // vettore delle curve dei percorsi di svuotatura dello step precedente - ICRVCOMPOPOVECTOR vRCrv_step_prec ; // vettore delle curve dei percorsi di ritorno dello step precedente - ICRVCOMPOPOVECTOR vMCrv_step_prec_tot ; // vettore delle curve dei percorsi di svuotatura dello step precedente con entrata - ICRVCOMPOPOVECTOR vRCrv_step_prec_tot ; // vettore delle curve dei percorsi di ritorno dello step precedente con uscita - vector vvtMidOutPrec ; // vettore dei versori delle direzioni di uscita dello step precedente - INTVECTOR vnRegTot_prec ; // vettore dei numeri delle regioni formate dal primo Offset nello step precedente - BOOLVECTOR vbOptTrap_prec ; // flags per caso ottimizzato svuotratura dello step precedente + // LeadIn/leadout + Point3d ptP1 ; + struct SpiralData { + BOOLVECTOR vbMidOut ; // flags per effettiva entrata precedente da fuori dal grezzo + ICRVCOMPOPOVECTOR vMCrv ; // vettore delle curve dei percorsi di svuotatura dello step precedente + ICRVCOMPOPOVECTOR vRCrv ; // vettore delle curve dei percorsi di ritorno dello step precedente + vector vvtMidOut ; // vettore dei versori delle direzioni di uscita dello step precedente + INTVECTOR vnRegTot ; // vettore dei numeri delle regioni formate dal primo Offset nello step precedente + BOOLVECTOR vbOptTrap ; + } ; + SpiralData SDStepPrec ; // informazioni Spiral attuali int nOffs_act = 0 ; // Shift indice dei vettori causato da nReg // scorro il vettore delle FlatRegion ( calcolate per ogni step j-esimo) for ( int j = 1 ; j <= nStep ; ++ j) { + SpiralData SDStepCurr ; // informazioni Spiral attuali + if ( ! vbChangedPrec[j-1]) { + for ( int i = 0 ; i < int( SDStepPrec.vMCrv.size()) ; ++ i) + SDStepCurr.vMCrv.emplace_back( SDStepPrec.vMCrv[i]->Clone()) ; + SDStepCurr.vbMidOut = SDStepPrec.vbMidOut ; + SDStepCurr.vnRegTot = SDStepPrec.vnRegTot ; + SDStepCurr.vvtMidOut = SDStepPrec.vvtMidOut ; + SDStepCurr.vbOptTrap = SDStepPrec.vbOptTrap ; + } + // se superficie non valida, passo alla prossima if ( IsNull( vSfr[j-1]) || ! vSfr[j-1]->IsValid()) continue ; @@ -5745,18 +5774,6 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& if ( IsNull( pSrfLeanInOut)) return false ; - // se lo step attuale è cambiato rispetto al precedente... - if ( vbChangedPrec[j-1]) { - // Flush info step precedente - vMCrv_step_prec.clear() ; - vRCrv_step_prec.clear() ; - vnRegTot_prec.clear() ; - vbMidOutPrec.clear() ; - vvtMidOutPrec.clear() ; - vbOptTrap_prec.clear() ; - nOffs_act = 0 ; - } - // creo le entità per lo step corrente ICRVCOMPOPOVECTOR vMCrv, vRCrv ; BOOLVECTOR vbOut ; @@ -5797,15 +5814,14 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& // NB. se la superficie è rimasta la stessa, utilizzo pMCrv e pRCrv dello step precedente // ( non c'è bisogno di ricalcolare tutti i percorsi) if ( ! vbChangedPrec[j-1] && j != 1) { - if ( nOffs_act > int( vMCrv_step_prec.size()) - 1) + if ( nOffs_act > int( SDStepPrec.vMCrv.size()) - 1) break ; - pMCrv.Set( vMCrv_step_prec[nOffs_act]->Clone()) ; - pRCrv.Set( vRCrv_step_prec[nOffs_act]->Clone()) ; - nRegTot = vnRegTot_prec[nOffs_act] ; - bMidOut = vbMidOutPrec[nOffs_act] ; - vMCrv_step_prec[nOffs_act]->GetStartPoint( ptStart) ; - vtMidOut = vvtMidOutPrec[nOffs_act] ; - bOptimizedTrap = vbOptTrap_prec[nOffs_act] ; + pMCrv.Set( SDStepPrec.vMCrv[nOffs_act]->Clone()) ; + pRCrv.Set( SDStepPrec.vRCrv[nOffs_act]->Clone()) ; + nRegTot = SDStepPrec.vnRegTot[nOffs_act] ; + bMidOut = SDStepPrec.vbMidOut[nOffs_act] ; + vtMidOut = SDStepPrec.vvtMidOut[nOffs_act] ; + bOptimizedTrap = SDStepPrec.vbOptTrap[nOffs_act] ; } else { // se lucidatura con epicicli @@ -5845,16 +5861,16 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& } // memorizzo le curve create e modificate per lo step successivo - vMCrv_step_prec.emplace_back( pMCrv->Clone()) ; - vRCrv_step_prec.emplace_back( pRCrv->Clone()) ; + SDStepCurr.vMCrv.emplace_back( pMCrv->Clone()) ; + SDStepCurr.vRCrv.emplace_back( pRCrv->Clone()) ; // memorizzo i Flag per le entrate - vbMidOutPrec.push_back( bMidOut) ; + SDStepCurr.vbMidOut.push_back( bMidOut) ; // memorizzo il numero delle regioni create dal primo Offset - vnRegTot_prec.push_back( nRegTot) ; + SDStepCurr.vnRegTot.push_back( nRegTot) ; // memorizzo il versore di uscita calcolato - vvtMidOutPrec.push_back( vtMidOut) ; + SDStepCurr.vvtMidOut.push_back( vtMidOut) ; // memorizzo caso ottimizzato - vbOptTrap_prec.push_back( bOptimizedTrap) ; + SDStepCurr.vbOptTrap.push_back( bOptimizedTrap) ; } // controlli per entrate da fuori al grezzo @@ -5886,6 +5902,8 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& if ( bOptimizedTrap) { AdjustTrapezoidSpiralForLeadInLeadOut( pMCrv, pRCrv, vtTool, dDepth, nOutsideRaw) ; bOutStart = ( nOutsideRaw > 0) ; + // aggiorno la curva per eventuali inversioni + SDStepCurr.vMCrv.back().Set( pMCrv->Clone()) ; } // verifico se l'ingresso è da considerare fuori dal grezzo anche se dentro @@ -5902,9 +5920,30 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& // se sono nel caso ottimizzato per Trapezi e ho attacco e uscita entrambi dentro/fuori dal grezzo, // ad ogni step pari inverto la direzione della curva solamente se ho un solo chunk e la superificie successiva // non è cambiata - if ( bOptimizedTrap && nOutsideRaw != 1 && j > 1 && vSfr[j-2]->GetChunkCount() == 1 && ! vbChangedPrec[j-1] - && ( j % 2 == 0)) - pMCrv->Invert() ; + if (( j > 1 && vSfr[j-1]->GetChunkCount() == 1 && int( SDStepPrec.vMCrv.size()) == 1 && + bOptimizedTrap && SDStepPrec.vbOptTrap[0])) { + Point3d ptA, ptB, ptC ; + pMCrv->GetStartPoint( ptA) ; + SDStepPrec.vMCrv[0]->GetStartPoint( ptB) ; + SDStepPrec.vMCrv[0]->GetEndPoint( ptC) ; + ptA.Translate( vVtTrasl[j-2] - vVtTrasl[j-1]) ; + bool bOpposite = ( Dist( ptA, ptB) > Dist( ptA, ptC) + EPS_SMALL) ; + switch ( nOutsideRaw) { + case 0 : + case 2 : + if ( ! bOpposite) { + pMCrv->Invert() ; + SDStepCurr.vMCrv[0]->Invert() ; + } + break ; + case 1 : + if ( bOpposite) { + pMCrv->Invert() ; + SDStepCurr.vMCrv[0]->Invert() ; + } + break ; + } + } ++ nReg ; // incremento del numero di regioni trovate ++ nOffs_act ; // shift indice @@ -5982,38 +6021,15 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& // per il percorso attuale else { PtrOwner pRCrv( CreateCurveComposite()) ; - if ( IsNull( pRCrv)) + // ricavo il punto in cui sono + Point3d ptCurr ; GetCurrPos( ptCurr) ; + // ricavo il punto che devo raggiungere + Point3d ptDest ; vMCrv[i]->GetStartPoint( ptDest) ; + // calcolo il percorso di ritorno del percorso attuale + if ( IsNull( pRCrv) || + ! CalcLinkOnStep( ptCurr, ptDest, vSfr[j-2], pRCrv)) { + m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ; return false ; - // se percorso già calcolato, allora uso questo - if ( vRCrv[i]->IsValid()) { - // copio la curva di ritorno - PtrOwner pRet( vRCrv[i]->Clone()) ; - if ( IsNull( pRet)) - return false ; - // se attacco a scivolo, accorcio della lunghezza dell'attacco - if ( GetLeadInType() == POCKET_LI_GLIDE) { - double dLen ; pRet->GetLength( dLen) ; - if ( dLen > m_Params.m_dLiTang + 10 * EPS_SMALL) { - if ( ! pRet->TrimEndAtLen( dLen - m_Params.m_dLiTang)) - pRet->Clear() ; - } - else - pRet->Clear() ; - } - pRCrv.Set( Release( pRet)) ; - } - // ... se devo calcolarlo - else { - // ricavo il punto in cui sono - Point3d ptCurr ; GetCurrPos( ptCurr) ; - // ricavo il punto che devo raggiungere - Point3d ptDest ; vMCrv[i]->GetStartPoint( ptDest) ; - // calcolo il percorso di ritorno del percorso attuale - if ( IsNull( pRCrv) || - ! CalcLinkOnStep( ptCurr, ptDest, vSfr[j-2], pRCrv)) { - m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ; - return false ; - } } // emetto int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pRCrv->Clone()) ; @@ -6077,9 +6093,15 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector& } } - // aggiorno i dati Spiral - vMCrv_step_prec_tot.swap( vMCrv) ; - vRCrv_step_prec_tot.swap( vRCrv) ; + // aggiorno i dati Spiral se regioni cambiate tra step + SDStepPrec.vMCrv.clear() ; + for ( int i = 0 ; i < int( SDStepCurr.vMCrv.size()) ; ++ i) + SDStepPrec.vMCrv.emplace_back( Release( SDStepCurr.vMCrv[i])) ; + SDStepPrec.vbMidOut = SDStepCurr.vbMidOut ; + SDStepPrec.vnRegTot = SDStepCurr.vnRegTot ; + SDStepPrec.vvtMidOut = SDStepCurr.vvtMidOut ; + SDStepPrec.vbOptTrap = SDStepCurr.vbOptTrap ; + } return true ; @@ -6144,9 +6166,17 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl pCrvStepLink->IsValid() && pCrvStepLink->ToGlob( frCurr) ; + + // se invece esistono intersezioni devo prendere in considerazione i tratti esterni alla regione - // su di essi calcolo l'elevazione considerata sopra la segmento + // originaria, l'elevazione è calcolata sui tratti esterni ad essa double dMAxElev = 0. ; + ccClass.clear() ; + PtrOwner pSfrCurr( CloneSurfFlatRegion( pSfr)) ; + if ( IsNull( pSfrCurr) || ! pSfrCurr->IsValid() || + ! pSfrCurr->ToLoc( frCurr) || + ! pSfrCurr->GetCurveClassification( *pSeg, EPS_SMALL, ccClass)) + return false ; for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) { if ( ccClass[i].nClass == CRVC_IN) continue ; @@ -6169,7 +6199,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl pCrvStepLink->AddLine( ptEProj + SAFE_Z_RET * Z_AX) && pCrvStepLink->IsValid() && pCrvStepLink->ToGlob( frCurr) ; - + // in questo caso creo un percorso con i Bisettori seguendo VRONI ICURVEPOVECTOR vCrvBisectors ; Voronoi* pVRONI( pSfr->GetVoronoiObject()) ; @@ -6177,7 +6207,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl ! pVRONI->CalcMedialAxis( vCrvBisectors, Voronoi::WMAT_LEFT) || vCrvBisectors.empty()) return false ; - + // porto i bisettori nel riferimento for ( int i = 0 ; i < ( int)vCrvBisectors.size() ; ++ i) vCrvBisectors[i]->ToLoc( frCurr) ; @@ -6192,11 +6222,43 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl if ( IsNull( pCrvPath) || ! ChooseBestBisectorPath( vCompoBisChain, ORIG, ptEProj, pCrvPath)) return false ; - // controllo che la curva si effettivamente distante dal percorso, altrimenti scarico - bool bSkip = false ; - for ( int j = 1 ; j < int( pCrvPath->GetCurveCount()) -1 && ! bSkip ; ++ j) + + // controllo che la curva si effettivamente valida e distante dal percorso, altrimenti scarico + bool bSkip = ! pCrvPath->IsValid() || pCrvPath->GetCurveCount() == 0 ; + + for ( int j = 0 ; j < int( pCrvPath->GetCurveCount()) && ! bSkip ; ++ j) bSkip = pCrvPath->GetCurve( j)->GetTempParam( 0) < m_TParams.m_dDiam * 0.5 || pCrvPath->GetCurve( j)->GetTempParam( 1) < m_TParams.m_dDiam * 0.5 ; + + if ( ! bSkip) { + // calcolo i tratti lineari di raccordo tra il percorso trovato e i punti iniziali e finali effettivi + Point3d ptS_path, ptE_path ; + if ( ! pCrvPath->GetStartPoint( ptS_path) || ! pCrvPath->GetEndPoint( ptE_path)) + return false ; + CRVCVECTOR ccClass_line ; + if ( ! AreSamePointEpsilon( ptS_path, ORIG, 5 * EPS_SMALL)) { + PtrOwner pLineToStart( CreateCurveLine()) ; + if ( IsNull( pLineToStart) || + ! pLineToStart->Set( ORIG, ptS_path) || + ! pSfrSafe->GetCurveClassification( *pLineToStart, EPS_SMALL, ccClass_line)) + return false ; + bSkip = ! ( int( ccClass_line.size()) == 1 && ccClass_line[0].nClass == CRVC_IN) ; + } + if ( ! bSkip) { + ccClass_line.clear() ; + if ( ! AreSamePointEpsilon( ptE_path, ptEProj, 5 * EPS_SMALL)) { + PtrOwner pLineToEnd( CreateCurveLine()) ; + if ( IsNull( pLineToEnd) || + ! pLineToEnd->Set( ptEProj, ptE_path) || + ! pSfrSafe->GetCurveClassification( *pLineToEnd, EPS_SMALL, ccClass_line)) + return false ; + bSkip = ! ( int( ccClass_line.size()) == 1 && ccClass_line[0].nClass == CRVC_IN) ; + } + } + } + + // se la curva non è valida, non sufficientemente lontana dal bordo della regione Safe o i raccordi + // lineari rovinano il grezzo, scarico if ( bSkip) return pCrvStepLink->AddPoint( ORIG) && pCrvStepLink->AddLine( ORIG + ( SAFE_Z_RET + dMAxElev) * Z_AX) && @@ -6204,16 +6266,16 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl ( dMAxElev - SAFE_Z_RET > 0 ? pCrvStepLink->AddLine( ptEProj + SAFE_Z_RET * Z_AX) : true) && pCrvStepLink->IsValid() && pCrvStepLink->ToGlob( frCurr) ; - + // aggiungo un tratto lineare per avere il percorso completo pCrvPath->AddLine( ORIG, false) ; pCrvPath->AddLine( ptEProj, true) ; - + // calcolo la sua lunghezza double dCurrLen ; if ( ! pCrvPath->GetLength( dCurrLen)) return false ; - + // merge delle curve e smusso il miglior percorso trovato pCrvPath->MergeCurves( 100 * EPS_SMALL, 100 * EPS_ANG_SMALL) ; // approssimo con PolyArc @@ -6224,7 +6286,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl pCrvPath->FromPolyArc( PA) ; ModifyCurveToSmoothed( pCrvPath, m_TParams.m_dDiam / 16, m_TParams.m_dDiam / 16, false) ; - + // valuto se invece è più conveniente scaricare ( quindi alzandomi di dMaxElev) // la lunghezza del tratto in salita e in discesa è dMaxElev // la lunghezza del tratto orizzontale è data dalla distanza tra ORIG e ptEProj @@ -6236,7 +6298,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl pCrvStepLink->AddCurve( Release( pCrvPath)) && pCrvStepLink->IsValid() && pCrvStepLink->ToGlob( frCurr) ; - + // privilegio lo scarico return pCrvStepLink->AddPoint( ORIG) && pCrvStepLink->AddLine( ORIG + ( SAFE_Z_RET + dMAxElev) * Z_AX) && @@ -6244,7 +6306,6 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl ( dMAxElev - SAFE_Z_RET > 0 ? pCrvStepLink->AddLine( ptEProj + SAFE_Z_RET * Z_AX) : true) && pCrvStepLink->IsValid() && pCrvStepLink->ToGlob( frCurr) ; - } //---------------------------------------------------------------------------- @@ -6466,8 +6527,19 @@ Pocketing::ChooseBestBisectorPath( ICRVCOMPOPOVECTOR& vCrvCompo, const Point3d& ( Links[i].nIndNodA == nIndPrecNode && Links[i].nIndNodB == nIndCurrNode)) { if ( ! pCrvPath->AddCurve( vCrvCompo[i]->Clone())) { vCrvCompo[i]->Invert() ; - if ( ! pCrvPath->AddCurve( vCrvCompo[i]->Clone())) + if ( ! pCrvPath->AddCurve( vCrvCompo[i]->Clone())) { + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvPath->Clone()) ; + m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvCompo[i]->Clone()) ; return false ; + } + } + // NB. Se la curva è la prima, il punto iniziale deve essere ptBisE ! + if ( nIndCurrNode == nDestInd) { + Point3d ptSPath ; + if ( ! pCrvPath->GetStartPoint( ptSPath)) + return false ; + if ( ! AreSamePointEpsilon( ptSPath, ptBisE, 5 * EPS_SMALL)) + pCrvPath->Invert() ; } break ; } @@ -6478,12 +6550,17 @@ Pocketing::ChooseBestBisectorPath( ICRVCOMPOPOVECTOR& vCrvCompo, const Point3d& // controllo se il percorso trovato è ammissibile e che il punto iniziale e finale che coincidano // a quelli ricavati Point3d ptSCheck, ptECheck ; - return pCrvPath->IsValid() && - pCrvPath->Invert() && - pCrvPath->GetStartPoint( ptSCheck) && - AreSamePointEpsilon( ptBisS, ptSCheck, 5 * EPS_SMALL) && - pCrvPath->GetEndPoint( ptECheck) && - AreSamePointEpsilon( ptBisE, ptECheck, 5 * EPS_SMALL) ; + bool bIsValid = pCrvPath->IsValid() && + pCrvPath->Invert() && + pCrvPath->GetStartPoint( ptSCheck) && + AreSamePointEpsilon( ptBisS, ptSCheck, 5 * EPS_SMALL) && + pCrvPath->GetEndPoint( ptECheck) && + AreSamePointEpsilon( ptBisE, ptECheck, 5 * EPS_SMALL) ; + // se non valida, potrebbe effettivamente non esistere un percorso + if ( ! bIsValid) + pCrvPath->Clear() ; + + return true ; } //---------------------------------------------------------------------------- @@ -11241,6 +11318,13 @@ Pocketing::GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveCompos return true ; } + // la curva a trapezio deve evere 4 lati + if ( pCrvTrap->GetCurveCount() != 4) { + pCrvTrap->Clear() ; + return true ; + } + + // se parametro MaxOptSize non compatibile => non è ottimizzato double dMaxOptSize ; FromString( ExtractInfo( m_Params.m_sUserNotes, "MaxOptSize="), dMaxOptSize) ; @@ -11707,7 +11791,7 @@ Pocketing::CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTr INTVECTOR vnProp( 4, 0) ; if ( pCrvPocket->GetCurveCount() == 4) { for ( int i = 0 ; i < 4 ; i++) - pCrvPocket->GetCurveTempProp( i, vnProp[i]) ; + pCrvPocket->GetCurveTempProp( i, vnProp[i]) ; } else { vnProp[1] = pCrvPocket->GetCurve( 1)->GetTempProp() ;