Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://gitlab.steamware.net/egaltech/EgtGeomKernel

Browse Source
This commit is contained in:
Riccardo Elitropi
2023-12-22 09:30:32 +01:00
parent 4e7501ed7f 1280037d1d
commit 0ae7e1876b
27 changed files with 850 additions and 537 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CalcPocketing.cpp
+136 -137
View File
@@ -15,10 +15,11 @@
#include "stdafx.h"
#include "DllMain.h"
#include "GeoConst.h"
#include "CurveArc.h"
#include "BiArcs.h"
#include "CurveLine.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "CurveArc.h"
#include "CurveComposite.h"
#include "BiArcs.h"
#include "SurfFlatRegion.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkCalcPocketing.h"
@@ -30,7 +31,6 @@
#include "EgtDev/Include/EGkLinePntTgCurve.h"
#include <array>
using namespace std ;
//----------------------------------------------------------------------------
@@ -43,15 +43,14 @@ enum { POCKET_ZIGZAG = 0,
POCKET_SPIRALOUT = 3 } ;
// variabili d'appoggio ( per non passare troppi parametri tra le funzioni secondarie)
int TYPE ;
double RAD ;
bool SMOOTH ;
static int s_nType = 0 ;
static double s_dRad = 0 ;
static bool s_bSmooth = false ;
//----------------------------------------------------------------------------
static bool
AdjustContourStart( ICurveComposite* pCompo)
{
// creo un vettore di indici che definisce l'ordine delle curve chiuse in base alla lunghezza
INTVECTOR vInd ; vInd.reserve( pCompo->GetCurveCount()) ;
@@ -109,9 +108,8 @@ AdjustContourStart( ICurveComposite* pCompo)
static bool
ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam)
{
// se non richiesto non faccio nulla
if ( ! SMOOTH)
if ( ! s_bSmooth)
return true ;
// controllo parametri
@@ -237,7 +235,7 @@ ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightLen, double dLeftLen,
}
// creo la curva che restituirò
PtrOwner<ICurveComposite> pCrvCO_temp( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCrvCO_temp( CreateBasicCurveComposite()) ;
if ( IsNull( pCrvCO_temp))
return false ;
Point3d ptArcHelp, ptFirstPoint ;
@@ -353,22 +351,22 @@ CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR
}
// creo la retta che li unisce
PtrOwner<ICurveComposite> pCompoLine( CreateCurveComposite()) ;
if ( ! pCompoLine->AddPoint( ptStart) || ! pCompoLine->AddLine( ptEnd))
PtrOwner<CurveComposite> pCompoLine( CreateBasicCurveComposite()) ;
if ( ! pCompoLine->AddPoint( ptStart) || ! pCompoLine->AddLine( ptEnd))
return false ;
pCompoLine->SetExtrusion( vtExtr) ;
// la porto in locale al riferimento della svuotatura
CurveLocal LineLoc( pCompoLine, GLOB_FRM, frLoc) ; // ... per le intersezioni
// creo la nuova curva formata dai tratti di linee INTERNI alle isole e dai tratti sul bordo degli offset
PtrOwner<ICurveComposite> pCompo( pCompoLine->Clone()) ;
PtrOwner<CurveComposite> pCompo( pCompoLine->Clone()) ;
if ( IsNull( pCompo) )
return false ;
if ( ! pCompo->LocToLoc( GLOB_FRM, frLoc) )
return false;
// memorizzo il tratto lineare nel caso qualche operazione fallisse
PtrOwner<ICurveComposite> pCompoHelp( pCompoLine->Clone()) ;
PtrOwner<CurveComposite> pCompoHelp( pCompoLine->Clone()) ;
if ( IsNull( pCompoHelp))
return false ;
if ( ! pCompoHelp->LocToLoc( GLOB_FRM, frLoc))
@@ -381,9 +379,10 @@ CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR
intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
if ( ! pCompoHelp->Clear())
return false ;
for ( int j = 0 ; j < int( ccClass.size()) ; ++j ) { // per ogni intersezione j con l'offset dell'isola i
if ( ccClass[j].nClass == CRVC_OUT) { // se ho intersezione spezzo il segmento
// per ogni intersezione j con l'offset dell'isola i
for ( int j = 0 ; j < int( ccClass.size()) ; ++j ) {
// se ho intersezione spezzo il segmento
if ( ccClass[j].nClass == CRVC_OUT) {
Point3d ptS ;
pCompo->GetPointD1D2( ccClass[j].dParS, ICurve::FROM_PLUS, ptS) ;
double dOffS ;
@@ -393,14 +392,13 @@ CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR
double dOffE ;
vOffIslands[i]->GetParamAtPoint( ptE, dOffE) ;
// recupero i due possibili percorsi e uso il più corto
PtrOwner<ICurve> pCrvA( GetCurve( vOffIslands[i]->CopyParamRange( dOffS, dOffE))) ;
PtrOwner<ICurve> pCrvB( GetCurve( vOffIslands[i]->CopyParamRange( dOffE, dOffS))) ;
if ( IsNull( pCrvA) || IsNull( pCrvB) )
PtrOwner<ICurve> pCrvA( vOffIslands[i]->CopyParamRange( dOffS, dOffE)) ;
PtrOwner<ICurve> pCrvB( vOffIslands[i]->CopyParamRange( dOffE, dOffS)) ;
if ( IsNull( pCrvA) || IsNull( pCrvB))
return false ;
double dLenA ; pCrvA->GetLength( dLenA) ;
double dLenB ; pCrvB->GetLength( dLenB) ;
if ( dLenA < dLenB ) {
if ( dLenA < dLenB) {
pCompoHelp->AddCurve( Release( pCrvA)) ;
}
else {
@@ -408,14 +406,14 @@ CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR
pCompoHelp->AddCurve( Release( pCrvB)) ;
}
}
else { // se non interseco
// se non interseco
else {
pCompoHelp->AddCurve( pCompo->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)) ;
}
}
pCompo->Clear() ;
pCompo->AddCurve( pCompoHelp->Clone()) ;
}
// riporto pCompo nel sistema di riferimento originale
@@ -424,7 +422,6 @@ CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR
pCrvLink->AddCurve( Release( pCompo)) ;
return true ;
}
//-----------------------------------------------------------------------------
@@ -444,30 +441,30 @@ ModifyBiArc( ICurve* pBiArcLink, double dToll, ICurveComposite* pNewBiArc)
pBiArcLink->GetDomain( dUS, dUE) ;
// prendo i due archi della curva BiArco
PtrOwner<ICurve> pArc1( GetCurve( pBiArcLink->CopyParamRange( dUS, ( dUS + dUE) / 2))) ;
PtrOwner<ICurve> pArc2( GetCurve( pBiArcLink->CopyParamRange(( dUS + dUE ) / 2, dUE))) ;
PtrOwner<ICurve> pArc1( pBiArcLink->CopyParamRange( dUS, ( dUS + dUE) / 2)) ;
PtrOwner<ICurve> pArc2( pBiArcLink->CopyParamRange(( dUS + dUE ) / 2, dUE)) ;
if ( IsNull( pArc1) || ! pArc1->IsValid() || IsNull( pArc2) || ! pArc2->IsValid())
return false ;
// primo pezzo
pArc1->GetDomain( dUS, dUE) ;
PtrOwner<ICurve> pArc1A( GetCurve( pArc1->CopyParamRange( dUS, dUS + ( dUE - dUS ) * dToll))) ; // Arc1
PtrOwner<ICurve> pArc1B( GetCurve( pArc1->CopyParamRange( dUE - ( dUE - dUS ) * dToll, dUE))) ; // Arc2
PtrOwner<ICurve> pArc1A( pArc1->CopyParamRange( dUS, dUS + ( dUE - dUS ) * dToll)) ; // Arc1
PtrOwner<ICurve> pArc1B( pArc1->CopyParamRange( dUE - ( dUE - dUS ) * dToll, dUE)) ; // Arc2
Point3d pt1A, pt1B ;
pArc1A->GetEndPoint( pt1A) ;
pArc1B->GetStartPoint( pt1B) ;
PtrOwner<ICurveLine> pLine1( CreateCurveLine()) ;
pLine1->Set( pt1A, pt1B) ; // Linea
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( pt1A, pt1B) ;
// secondo pezzo
pArc2->GetDomain( dUS, dUE) ;
PtrOwner<ICurve> pArc2A( GetCurve( pArc2->CopyParamRange( dUS, dUS + ( dUE - dUS ) * dToll))) ; // Arc1
PtrOwner<ICurve> pArc2B( GetCurve( pArc2->CopyParamRange( dUE - ( dUE - dUS ) * dToll, dUE))) ; // Arc2
PtrOwner<ICurve> pArc2A( pArc2->CopyParamRange( dUS, dUS + ( dUE - dUS ) * dToll)) ; // Arc1
PtrOwner<ICurve> pArc2B( pArc2->CopyParamRange( dUE - ( dUE - dUS ) * dToll, dUE)) ; // Arc2
Point3d pt2A, pt2B ;
pArc2A->GetEndPoint( pt2A) ;
pArc2B->GetStartPoint( pt2B) ;
PtrOwner<ICurveLine> pLine2( CreateCurveLine()) ;
pLine2->Set( pt2A, pt2B) ; // Linea
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( pt2A, pt2B) ;
// ricostruisco il nuovo link
if ( ! pNewBiArc->AddCurve( Release( pArc1A)) ||
@@ -487,9 +484,8 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
const Vector3d& vtEnd, double dParMeet, ICRVCOMPOPOVECTOR& vOffIslands,
ICurveComposite* pCrvLink)
{
// se senza smusso, ritorno tratto lineare
if ( ! SMOOTH)
if ( ! s_bSmooth)
return CalcBoundedLink( ptStart, ptEnd, vOffIslands, pCrvLink) ;
// creo il BiArc che unisce i due punti
@@ -500,7 +496,7 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
if ( dParMeet != 0)
pBiArcLink.Set( GetBiArc( ptStart, -dAngStart, ptEnd, -dAngEnd, dParMeet)) ;
else {
PtrOwner<ICurveArc> pCrvCir( CreateCurveArc()) ;
PtrOwner<CurveArc> pCrvCir( CreateBasicCurveArc()) ;
if ( IsNull( pCrvCir))
return false ;
pCrvCir->SetCPAN( Media( ptStart, ptEnd), ptStart, - 360, 0, Z_AX) ;
@@ -515,7 +511,7 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
double dLenBiArc ;
pBiArcLink->GetLength( dLenBiArc) ;
if ( dLenBiArc > 200 * 1000 * EPS_SMALL) {
PtrOwner<ICurveComposite> pCrvNewBiArcS( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCrvNewBiArcS( CreateBasicCurveComposite()) ;
ModifyBiArc( pBiArcLink, 0.2, pCrvNewBiArcS) ;
pBiArcLink.Set( pCrvNewBiArcS) ;
}
@@ -536,10 +532,10 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
if ( ! pCompoHelp->Clear())
return false ;
for ( int j = 0 ; j < int( ccClass.size()) ; ++ j) { // per ogni intersezione j con l'offset dell'isola i
if ( ccClass[j].nClass == CRVC_OUT && ccClass.size() > 1) { // se ho intersezione spezzo il segmento
// per ogni intersezione j con l'offset dell'isola i
for ( int j = 0 ; j < int( ccClass.size()) ; ++ j) {
// se ho intersezione spezzo il segmento
if ( ccClass[j].nClass == CRVC_OUT && ccClass.size() > 1) {
Point3d ptS ;
pCompo->GetPointD1D2( ccClass[j].dParS, ICurve::FROM_PLUS, ptS) ;
double dOffS ;
@@ -549,8 +545,8 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
double dOffE ;
vOffIslands[i]->GetParamAtPoint( ptE, dOffE, 1500 * EPS_SMALL) ;
// recupero i due possibili percorsi e uso il più corto
PtrOwner<ICurve> pCrvA( GetCurve( vOffIslands[i]->CopyParamRange( dOffS, dOffE))) ;
PtrOwner<ICurve> pCrvB( GetCurve( vOffIslands[i]->CopyParamRange( dOffE, dOffS))) ;
PtrOwner<ICurve> pCrvA( vOffIslands[i]->CopyParamRange( dOffS, dOffE)) ;
PtrOwner<ICurve> pCrvB( vOffIslands[i]->CopyParamRange( dOffE, dOffS)) ;
if ( IsNull( pCrvA) || IsNull( pCrvB))
return CalcBoundedLink( ptStart, ptEnd, vOffIslands, pCrvLink) ;
@@ -575,7 +571,8 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
return CalcBoundedLink( ptStart, ptEnd, vOffIslands, pCrvLink) ;
}
}
else { // se non interseco
// se non interseco
else {
if ( ! pCompoHelp->AddCurve( pCompo->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)))
return CalcBoundedLink( ptStart, ptEnd, vOffIslands, pCrvLink) ;
}
@@ -585,7 +582,6 @@ CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const P
if ( ! pCompo->AddCurve( pCompoHelp->Clone()))
if ( ! CalcBoundedLink( ptStart, ptEnd, vOffIslands, pCrvLink))
return false ;
}
// se il BiArco è troppo piccolo allora lo approssimo con un segmento
@@ -618,7 +614,7 @@ CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, ICRVCOMPOPOVE
pCrvLink->Clear() ;
// curva finale da restituire
PtrOwner<ICurveComposite> ptCrvFinal( CreateCurveComposite()) ;
PtrOwner<CurveComposite> ptCrvFinal( CreateBasicCurveComposite()) ;
if ( IsNull( ptCrvFinal))
return false ;
@@ -645,8 +641,8 @@ CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, ICRVCOMPOPOVE
if ( vFirstOffset[i]->IsPointOn( ptES) && vFirstOffset[i]->IsPointOn( ptEE))
dLenPercE = 0 ;
}
double dLStepS = dLenPercS < EPS_SMALL ? 0. : RAD ;
double dLStepE = dLenPercE < EPS_SMALL ? 0. : RAD ;
double dLStepS = ( dLenPercS < EPS_SMALL ? 0. : s_dRad) ;
double dLStepE = ( dLenPercE < EPS_SMALL ? 0. : s_dRad) ;
dLenE = 0 ;
// calcolo i possibili BiArchi tra le due curve
@@ -656,7 +652,7 @@ CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, ICRVCOMPOPOVE
while ( nIter < nMaxIter) {
// calcolo il BiArco
PtrOwner<ICurveComposite> ptBiArc( CreateCurveComposite()) ;
PtrOwner<CurveComposite> ptBiArc( CreateBasicCurveComposite()) ;
if ( ! CalcBoundedSmootedLink( ptSE, vS, ptES, vE, 0.5, vFirstOffset, ptBiArc) ||
ptBiArc->GetCurveCount() == 0)
return false ;
@@ -701,7 +697,6 @@ CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, ICRVCOMPOPOVE
pCrvE_clone->GetStartDir( vE) ;
++ nIter ;
}
pCrvLink->AddCurve( ptCrvFinal->Clone()) ; // ultimo arco valido trovato
@@ -716,12 +711,12 @@ GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICU
{
// controllo dei parametri
if ( vFirstOffs.size() == 0 || ( int)vCrvs.size() < ( int)vFirstOffs.size())
if ( vFirstOffs.empty() || vCrvs.size() < vFirstOffs.size())
return false ;
pSrfToCut->Clear() ;
// 1) creo la regione esterna
PtrOwner<ISurfFlatRegion> pSrfExtern( CreateSurfFlatRegion()) ;
PtrOwner<SurfFlatRegion> pSrfExtern( CreateBasicSurfFlatRegion()) ;
if ( IsNull( pSrfExtern))
return false ;
@@ -736,24 +731,24 @@ GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICU
}
// 2) Creo la regione svuotata dal Tool negli Offset, nei Links e sia dagli Offsets che dai Links
PtrOwner<ISurfFlatRegion> pSrfTool_Offs( CreateSurfFlatRegion()) ;
PtrOwner<ISurfFlatRegion> pSrfTool_Links( CreateSurfFlatRegion()) ;
PtrOwner<ISurfFlatRegion> pSrfTool( CreateSurfFlatRegion()) ;
PtrOwner<SurfFlatRegion> pSrfTool_Offs( CreateBasicSurfFlatRegion()) ;
PtrOwner<SurfFlatRegion> pSrfTool_Links( CreateBasicSurfFlatRegion()) ;
PtrOwner<SurfFlatRegion> pSrfTool( CreateBasicSurfFlatRegion()) ;
if ( IsNull( pSrfTool_Offs) || IsNull( pSrfTool_Links) || IsNull( pSrfTool))
return false ;
// creo un vettore che conterrà solamente i Link percorsi fino ad Ora
ICRVCOMPOPOVECTOR vLinks_done ;
for ( int i = TYPE == POCKET_SPIRALIN ? 0 : ( int)vCrvs.size() - 1 ;
TYPE == POCKET_SPIRALIN ? i < int( vCrvs.size()) : i >= 0 ;
TYPE == POCKET_SPIRALIN ? ++ i : -- i) {
for ( int i = ( s_nType == POCKET_SPIRALIN ? 0 : ( int)vCrvs.size() - 1) ;
( s_nType == POCKET_SPIRALIN ? i < int( vCrvs.size()) : i >= 0) ;
( s_nType == POCKET_SPIRALIN ? ++ i : -- i)) {
// ================= LINK ================================
if ( i <= ( int)vLinks.size() && ! IsNull( vLinks[i]) && vLinks[i]->IsValid()) {
if ( i <= int( vLinks.size()) && ! IsNull( vLinks[i]) && vLinks[i]->IsValid()) {
// prendo il Link i-esimo come composita ( potrebbe essere tratto lineare)
PtrOwner<ICurveComposite> pCompoLink_i( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCompoLink_i( CreateBasicCurveComposite()) ;
if ( IsNull( pCompoLink_i))
return false ;
pCompoLink_i->AddCurve( vLinks[i]->Clone()) ;
@@ -762,10 +757,10 @@ GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICU
PtrOwner<ICurve> pCrvLink_i( vLinks[i]->Clone()) ;
if ( IsNull( pCrvLink_i))
return false ;
PtrOwner<ISurfFlatRegion> pSrfToolRegLinki( GetSurfFlatRegionFromFatCurve( Release( pCrvLink_i), RAD + 5 * EPS_SMALL, false, false)) ;
PtrOwner<ISurfFlatRegion> pSrfToolRegLinki( GetSurfFlatRegionFromFatCurve( Release( pCrvLink_i), s_dRad + 5 * EPS_SMALL, false, false)) ;
if ( ! IsNull( pSrfToolRegLinki)) {
if ( ! pSrfTool_Links->IsValid() || pSrfTool_Links->GetChunkCount() == 0)
pSrfTool_Links.Set( pSrfToolRegLinki) ;
pSrfTool_Links.Set( GetBasicSurfFlatRegion( pSrfToolRegLinki)) ;
else
pSrfTool_Links->Add( *pSrfToolRegLinki) ;
}
@@ -779,13 +774,13 @@ GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICU
// ================== OFFSET =============================
// aggiorno la superficie svuotata
PtrOwner<ICurveComposite> pCrvOffs_i( CloneCurveComposite( vCrvs[i])) ;
PtrOwner<CurveComposite> pCrvOffs_i( CloneBasicCurveComposite( vCrvs[i])) ;
if ( IsNull( pCrvOffs_i))
return false ;
PtrOwner<ISurfFlatRegion> pSrfToolRegOffi( GetSurfFlatRegionFromFatCurve( Release( pCrvOffs_i) , RAD + 5 * EPS_SMALL, false, false)) ;
PtrOwner<ISurfFlatRegion> pSrfToolRegOffi( GetSurfFlatRegionFromFatCurve( Release( pCrvOffs_i) , s_dRad + 5 * EPS_SMALL, false, false)) ;
if ( ! IsNull( pSrfToolRegOffi)) {
if ( ! pSrfTool_Offs->IsValid() || pSrfTool_Offs->GetChunkCount() == 0)
pSrfTool_Offs.Set( Release( pSrfToolRegOffi)) ;
pSrfTool_Offs.Set( GetBasicSurfFlatRegion( Release( pSrfToolRegOffi))) ;
else
pSrfTool_Offs->Add( *pSrfToolRegOffi) ;
}
@@ -811,15 +806,15 @@ RemoveFirstLoopFromSfr( ISurfFlatRegion* pSrfOrig)
if ( pSrfOrig == nullptr)
return true ;
// superficie da restituire
PtrOwner<ISurfFlatRegion> pSrfRes( CreateSurfFlatRegion()) ;
PtrOwner<SurfFlatRegion> pSrfRes( CreateBasicSurfFlatRegion()) ;
if ( IsNull( pSrfRes))
return false ;
// scorro tutti i chunk tranne il primo ( escludo quindi il primo chunk)
for ( int c = 1 ; c < pSrfOrig->GetChunkCount() ; ++ c) {
PtrOwner<ISurfFlatRegion> pSrfHelp( CreateSurfFlatRegion()) ;
PtrOwner<SurfFlatRegion> pSrfHelp( CreateBasicSurfFlatRegion()) ;
if ( IsNull( pSrfHelp))
return false ;
PtrOwner<ICurveComposite> pCrvMiniChunkBorder( GetCurveComposite( pSrfOrig->GetLoop( c, 0))) ;
PtrOwner<CurveComposite> pCrvMiniChunkBorder( GetBasicCurveComposite( pSrfOrig->GetLoop( c, 0))) ;
pSrfHelp->AddExtLoop( pCrvMiniChunkBorder->Clone()) ;
if ( c == 1)
pSrfRes.Set( pSrfHelp->Clone()) ;
@@ -848,7 +843,7 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
return false ;
// curva che l'utensile dovrà seguire per svuotare la regione e curva di ingombro del tool
PtrOwner<ICurveComposite> pCrvStepByStepPath( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCrvStepByStepPath( CreateBasicCurveComposite()) ;
if ( IsNull( pCrvStepByStepPath))
return false ;
@@ -868,9 +863,9 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
nIter++ ;
PtrOwner<ISurfFlatRegion> pSrfBiggerChunk( pSrfChunkToCutClone->CloneChunk( 0)) ;
if( IsNull( pSrfBiggerChunk))
if ( IsNull( pSrfBiggerChunk))
return false ;
if( ! pSrfBiggerChunk->IsValid())
if ( ! pSrfBiggerChunk->IsValid())
break ;
double dAreaExt ;
@@ -889,28 +884,30 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
break ;
// creo la superficie che racchiude il mio tool
PtrOwner<ICurveArc> pCrvToolShape( CreateCurveArc()) ;
PtrOwner<CurveArc> pCrvToolShape( CreateBasicCurveArc()) ;
if ( IsNull( pCrvToolShape))
return false ;
pCrvToolShape->SetXY( ptC, RAD + 5 * EPS_SMALL) ;
PtrOwner<ISurfFlatRegion> pSrfTool( CreateSurfFlatRegion()) ;
pCrvToolShape->SetXY( ptC, s_dRad + 5 * EPS_SMALL) ;
PtrOwner<SurfFlatRegion> pSrfTool( CreateBasicSurfFlatRegion()) ;
if ( IsNull( pSrfTool) || ! pSrfTool->AddExtLoop( Release( pCrvToolShape)) ||
! pSrfTool->IsValid())
! pSrfTool->IsValid())
break ;
PtrOwner<ISurfFlatRegion> pSrfTest( CloneSurfFlatRegion( pSrfBiggerChunk)) ;
if( IsNull( pSrfTest))
PtrOwner<SurfFlatRegion> pSrfTest( CloneBasicSurfFlatRegion( pSrfBiggerChunk)) ;
if ( IsNull( pSrfTest))
return false ;
pSrfTest->Subtract( *pSrfTool) ;
if( IsNull( pSrfTest) || ! pSrfTest->IsValid() || ! pSrfTest->GetArea( dArea) || dArea < 10 * EPS_SMALL ||
bForceCentroid) {
if ( nIter == 1) { // se prima iterazione -> ritorno il centroide con punto
if ( IsNull( pSrfTest) || ! pSrfTest->IsValid() || ! pSrfTest->GetArea( dArea) || dArea < 10 * EPS_SMALL ||
bForceCentroid) {
// se prima iterazione -> ritorno il centroide con punto
if ( nIter == 1) {
nOptFlag = 1 ;
ptCentroid = ptC ;
return true ;
}
else { // se non sono alla prima iterazione -> memorizzo il centroide nel vettore
// se non sono alla prima iterazione -> memorizzo il centroide nel vettore
else {
// controllo di non aver trovato un centroide già inserito ( per simmetria del chunk)
for ( int cen = 0 ; cen < int( vPtCentroid.size()) ; ++ cen) {
if ( AreSamePointApprox( vPtCentroid[cen], ptC)) {
@@ -920,7 +917,7 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
}
vPtCentroid.push_back( ptC) ;
pSrfChunkToCutClone->Subtract( *pSrfTool) ;
if( IsNull( pSrfChunkToCutClone) || ! pSrfChunkToCutClone->IsValid())
if ( IsNull( pSrfChunkToCutClone) || ! pSrfChunkToCutClone->IsValid())
break ;
continue ;
}
@@ -940,7 +937,7 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
continue ;
}
PtrOwner<ICurveComposite> pCrvMedAx( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCrvMedAx( CreateBasicCurveComposite()) ;
if ( IsNull( pCrvMedAx))
return false ;
if ( ! pCrvMedAx->FromPolyLine( PlMedAx)) {
@@ -972,7 +969,7 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
}
// 3) guardo quale regione svuoto con questa curva
PtrOwner<ISurfFlatRegion> pSrfRemoved( GetSurfFlatRegionFromFatCurve( Release( pCrvMedAx), RAD + 5 * EPS_SMALL, false, false)) ;
PtrOwner<ISurfFlatRegion> pSrfRemoved( GetSurfFlatRegionFromFatCurve( Release( pCrvMedAx), s_dRad + 5 * EPS_SMALL, false, false)) ;
if ( IsNull( pSrfRemoved) || ! pSrfRemoved->IsValid())
break ;
@@ -985,13 +982,14 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
}
// se entrambi i vettori sono vuoti l'area originaria era più piccola di 10 * EPS_SMALL -> non faccio nulla
if (( int)vCrvCoMedAxi.size() == 0 && ( int)vPtCentroid.size() == 0) {
if ( vCrvCoMedAxi.empty() && vPtCentroid.empty()) {
nOptFlag = 0 ;
return true ;
}
// ora collego la varie curve medial Axis trovate tra loro (ottenendo quindi una curva che svuota tutta la regione)
PtrOwner<ICurveComposite> pCrvCoBackLink( CreateCurveComposite()) ; // curva che collega primo e ultimo medial Axis
// curva che collega primo e ultimo medial Axis
PtrOwner<CurveComposite> pCrvCoBackLink( CreateBasicCurveComposite()) ;
if ( IsNull( pCrvCoBackLink))
return false ;
Point3d ptSOriginal, ptEOriginal ;
@@ -1015,7 +1013,7 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
! vCrvCoMedAxi[i-1]->GetEndDir( vtS))
return false ;
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCrvLink( CreateBasicCurveComposite()) ;
if ( IsNull( pCrvLink))
return false ;
@@ -1025,13 +1023,12 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
if ( ! pCrvPath->AddCurve( pCrvLink->Clone()) || ! pCrvPath->AddCurve( vCrvCoMedAxi[i]->Clone()))
return false ;
}
if ( ! AreSamePointEpsilon( ptEOriginal, ptSOriginal, EPS_SMALL))
if ( ! CalcBoundedSmootedLink( ptEOriginal, vtEOriginal, ptSOriginal, vtSOriginal, 0.5, vOffsFirstCurve, pCrvCoBackLink))
if ( ! CalcBoundedLink( ptEOriginal, ptSOriginal, vOffsFirstCurve, pCrvCoBackLink))
return false ;
if ( ! AreSamePointEpsilon( ptEOriginal, ptSOriginal, EPS_SMALL) &&
! CalcBoundedSmootedLink( ptEOriginal, vtEOriginal, ptSOriginal, vtSOriginal, 0.5, vOffsFirstCurve, pCrvCoBackLink) &&
! CalcBoundedLink( ptEOriginal, ptSOriginal, vOffsFirstCurve, pCrvCoBackLink))
return false ;
// se ho trovato dei centroidi li unisco nei punti più vicini a questo percorso
for ( int i = 0 ; i < int( vPtCentroid.size()) ; ++ i) {
@@ -1045,10 +1042,10 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
if ( ! pCrvPath->GetParamAtPoint( ptClosestOnPath, dU))
return false ;
PtrOwner<ICurveComposite> pCrvA( GetCurveComposite( pCrvPath->CopyParamRange( 0, dU))) ;
PtrOwner<CurveComposite> pCrvA( GetBasicCurveComposite( pCrvPath->CopyParamRange( 0, dU))) ;
if ( IsNull( pCrvA))
return false ;
PtrOwner<ICurveComposite> pCrvB( GetCurveComposite( pCrvPath->CopyParamRange( dU, pCrvPath->GetCurveCount()))) ;
PtrOwner<CurveComposite> pCrvB( GetBasicCurveComposite( pCrvPath->CopyParamRange( dU, pCrvPath->GetCurveCount()))) ;
if ( IsNull( pCrvB))
return false ;
@@ -1058,17 +1055,17 @@ RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECT
return false ;
// 4) collego i due punti (centroide e punto più vicino alla curva)
PtrOwner<ICurveComposite> pCrvPath1( CreateCurveComposite()) ;
PtrOwner<CurveComposite> pCrvPath1( CreateBasicCurveComposite()) ;
if ( IsNull( pCrvPath1))
return false ;
if ( ! CalcBoundedSmootedLink( ptClosestOnPath, vtTanCpt, vPtCentroid[i], vtTanCpt, 0, vOffsFirstCurve, pCrvPath1))
if ( ! CalcBoundedLink( ptClosestOnPath, vPtCentroid[i], vOffsFirstCurve, pCrvPath1))
return false ;
if ( ! CalcBoundedSmootedLink( ptClosestOnPath, vtTanCpt, vPtCentroid[i], vtTanCpt, 0, vOffsFirstCurve, pCrvPath1) &&
! CalcBoundedLink( ptClosestOnPath, vPtCentroid[i], vOffsFirstCurve, pCrvPath1))
return false ;
pCrvPath->Clear() ;
pCrvPath->AddCurve( Release( pCrvA)) ;
if( ! pCrvPath->AddCurve( Release( pCrvPath1)))
if ( ! pCrvPath->AddCurve( Release( pCrvPath1)))
return false ;
pCrvPath->AddCurve( Release( pCrvB)) ;
}
@@ -1086,9 +1083,8 @@ static bool
CutOffsetToClosestPoint( ICRVCOMPOPOVECTOR& vCurves, const Point3d& ptFocus,
ICurveComposite* pCrv1, ICurveComposite* pCrv2, int& nIndex)
{
// controllo di avere almeno un offset...
if (( int)vCurves.size() == 0)
if ( vCurves.empty())
return false ;
// variabili iniziali
@@ -1101,10 +1097,10 @@ CutOffsetToClosestPoint( ICRVCOMPOPOVECTOR& vCurves, const Point3d& ptFocus,
Point3d ptCL ;
// scorro tutti gli offset ad eccezione del primo ( a meno di averne uno solo )
for ( int j = ( int)vCurves.size() == 1 ? 0 : 1 ; j < int( vCurves.size()) ; ++ j) {
for ( int j = ( int( vCurves.size()) == 1 ? 0 : 1) ; j < int( vCurves.size()) ; ++ j) {
// non ho offset nulli, però controllo...
if( IsNull( vCurves[j]))
if ( IsNull( vCurves[j]))
continue ;
// prendo il punto più vicino
@@ -1194,7 +1190,7 @@ static bool
CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) {
// controllo parametri ingresso
if (( int)vOffs.size() == 0)
if ( vOffs.empty())
return true ;
// vettore di curve ausiliario
@@ -1242,8 +1238,8 @@ CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) {
Point3d ptE ; pCompo->GetPointD1D2( ccClass[j].dParE, ICurve::FROM_MINUS, ptE) ;
double dOffE ; vOffOrig[i]->GetParamAtPoint( ptE, dOffE) ;
// recupero i due possibili percorsi e uso il più corto
PtrOwner<ICurve> pCrvA( GetCurve( vOffOrig[i]->CopyParamRange( dOffS, dOffE))) ;
PtrOwner<ICurve> pCrvB( GetCurve( vOffOrig[i]->CopyParamRange( dOffE, dOffS))) ;
PtrOwner<ICurve> pCrvA( vOffOrig[i]->CopyParamRange( dOffS, dOffE)) ;
PtrOwner<ICurve> pCrvB( vOffOrig[i]->CopyParamRange( dOffE, dOffS)) ;
if ( IsNull( pCrvA) || IsNull( pCrvB))
return false ;
@@ -1314,7 +1310,8 @@ GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite*
Point3d ptS, ptE = ptC ;
Vector3d vtTanS, vtTanE ;
if ( bCir) { // creo una circonferenza
// creo una circonferenza
if ( bCir) {
// prendo il punto iniziale
if ( pCrvH1 == nullptr || pCrvH1->GetFirstCurve() == nullptr) {
if ( ! pCrvH2->GetStartPoint( ptS))
@@ -1355,7 +1352,8 @@ GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite*
if ( ! pCrvNewCurve->AddCurve(( pCrvH2->Clone()))) // aggiungo la fine
return false ;
}
else { // creo un BiArco
// creo un BiArco
else {
// prendo il vettore tangente e il punto iniziale
if ( pCrvH1 == nullptr || pCrvH1->GetFirstCurve() == nullptr) {
@@ -1411,13 +1409,13 @@ ManageSmoothAndAutoInters( ICurveComposite* pCrv, ICurveComposite* pCrvPath, ICu
while ( ! bFound && nIter < 45) {
vTanE.Rotate( Z_AX, 90 - nIter) ; // vettore perpendicolare
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
pLine->SetPVL( ptHS, vTanE, ( 2. * RAD) / 3 - 5 * EPS_SMALL) ; // segmento uscente
pLine->SetPVL( ptHS, vTanE, ( 2 * s_dRad) / 3 - 5 * EPS_SMALL) ; // segmento uscente
CRVCVECTOR ccClass ;
IntersCurveCurve intCC( *pLine, *pCrv) ;
intCC.GetCurveClassification( 0, EPS_SMALL, ccClass) ;
if (( int)ccClass.size() > 1) // se intersezione con parte precedente inverto la direzione
pLine->SetPVL( ptHS, - vTanE, ( 2. * RAD) / 3 - 5 * EPS_SMALL) ;
pLine->SetPVL( ptHS, - vTanE, ( 2 * s_dRad) / 3 - 5 * EPS_SMALL) ;
if ( IsNull( pLine) || ! pLine->IsValid())
break ;
@@ -1709,7 +1707,7 @@ RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMP
ICRVCOMPOPOVECTOR& vOffsFirstCurve, ICURVEPOVECTOR& vLinks)
{
if ( pSrfToCut == nullptr || ( int)vOffs.size() == 0)
if ( pSrfToCut == nullptr || vOffs.empty())
return true ;
// ciclo tutti i chunk della regione da tagliare
@@ -1961,7 +1959,7 @@ CalcSpiral( const ISurfFlatRegion* pSrfPock, double dRad, double dStep, bool bSm
}
// se non ho trovato curve di Offset allora esco
if (( int)vOffs.size() == 0)
if ( vOffs.empty())
return true ;
// cambio il punto iniziale della prima Curva di Offset
@@ -1971,7 +1969,7 @@ CalcSpiral( const ISurfFlatRegion* pSrfPock, double dRad, double dStep, bool bSm
ICRVCOMPOPOVECTOR vOffsClosedCurves( vOffs.size()) ; // vettore con tutte le curve di Offset Chiuse
for ( int i = 0 ; i < int( vOffs.size()) ; ++ i) {
if ( i != 0) {
ModifyCurveToSmoothed( vOffs[i], RAD / 8, RAD/8, false) ;
ModifyCurveToSmoothed( vOffs[i], s_dRad / 8, s_dRad / 8, false) ;
vOffs[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, true, true) ;
}
vOffsClosedCurves[i].Set( vOffs[i]->Clone()) ;
@@ -1981,7 +1979,7 @@ CalcSpiral( const ISurfFlatRegion* pSrfPock, double dRad, double dStep, bool bSm
for ( int i = 0 ; i < int( vOffsFirstCurve.size()) ; ++ i) {
if ( i != 0)
ModifyCurveToSmoothed( vOffsFirstCurve[i], RAD/8, RAD/8, false) ;
ModifyCurveToSmoothed( vOffsFirstCurve[i], s_dRad / 8, s_dRad / 8, false) ;
vOffsFirstCurve[i]->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
}
@@ -2044,7 +2042,7 @@ CalcSpiral( const ISurfFlatRegion* pSrfPock, double dRad, double dStep, bool bSm
PtrOwner<ICurveComposite> pOff_i1( CloneCurveComposite( vOffs[i + 1])) ;
// cerco di tagliare le curve e di raccordarle ( -> ottenendo il collegamento)
// NB. se la curva di offset è la prima, non devo tagliarla, accorcio solo le successive ( se non bordi di isole) ...
if ( ! SMOOTH || ! CutCurveToConnect( vOffs[i], vOffs[i+1], vOffsClosedCurves, vOffsFirstCurve, pCrvTest, i == 0 ? 0 : 0.01, 0.01, 2)) {
if ( ! s_bSmooth || ! CutCurveToConnect( vOffs[i], vOffs[i+1], vOffsClosedCurves, vOffsFirstCurve, pCrvTest, ( i == 0 ? 0 : 0.01), 0.01, 2)) {
// se non sono riuscito ad accorcirle, ritorno alla configurazione iniziale
PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
if ( IsNull( pCrvLink))
@@ -2170,9 +2168,8 @@ CheckSimpleOverlap( const ICurve* pCrv, const ICurveComposite* pCrvOri, int& nSt
static bool
CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite* pCrvLink)
{
// se non richiesto, esco
if ( ! SMOOTH)
if ( ! s_bSmooth)
return true ;
// controllo dei parametri
@@ -2256,8 +2253,8 @@ CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite*
pCrvTempLink->GetLastCurve()->GetLength( dLenI_e) ;
// raccordo pSeg1 con pCrvLink
double dTollLeft = 1 - ( dLen1 - ( ( 2 * RAD) / 16)) / dLen1 ; // % parametro sinistro per smusso
double dTollRight = ( ( 2 * RAD) / 16) / dLenI_s ; // % parametro destro di smusso
double dTollLeft = 1 - ( dLen1 - ( ( 2 * s_dRad) / 16)) / dLen1 ; // % parametro sinistro per smusso
double dTollRight = ( ( 2 * s_dRad) / 16) / dLenI_s ; // % parametro destro di smusso
PtrOwner<ICurveComposite> pCrv_Seg1_Isl( CreateCurveComposite()) ; // curva unione di pSeg1 e pCrvLink smussata
pCrv_Seg1_Isl->AddCurve( pCrvH1->Clone()) ;
pCrv_Seg1_Isl->AddCurve( pCrvTempLink->Clone()) ;
@@ -2267,8 +2264,8 @@ CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite*
double dUS_1IH, dUE_1IH, dToTLen ;
pCrv_Seg1_Isl->GetDomain( dUS_1IH, dUE_1IH) ; // dominio della curva smussata tra pSeg1 e PCrvLink
pCrv_Seg1_Isl->GetLength( dToTLen) ; // nuova lunghezza della curva smussata tra pSeg1 e pCrvLink
dTollLeft = 1 - ( dLenI_e - ( ( 2 * RAD) / 16)) / dLenI_e ; // % paramtro sinistro per smusso
dTollRight = ( ( 2 * RAD) / 16) / dLen2 ; // % parametro destro per smusso
dTollLeft = 1 - ( dLenI_e - ( ( 2 * s_dRad) / 16)) / dLenI_e ; // % paramtro sinistro per smusso
dTollRight = ( ( 2 * s_dRad) / 16) / dLen2 ; // % parametro destro per smusso
PtrOwner<ICurveComposite> pCrv_smoothed( CreateCurveComposite()) ; // curva unione del primo smusso con pSeg2
pCrv_smoothed->AddCurve( pCrv_Seg1_Isl->Clone()) ;
pCrv_smoothed->AddCurve( pCrvH2->Clone()) ;
@@ -2385,7 +2382,7 @@ CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double
if ( ! bFromInfill)
ptStart.Set( ptMin.x - EXP_LEN, ptMin.y + 10 * EPS_SMALL + i * dYStep, ptMin.z + dDimZ) ;
else {
double dShift = ( i == 0) ? 10 * EPS_SMALL : (( i == nYStep) ? - 10 * EPS_SMALL : 0.) ;
double dShift = ( i == 0 ? 10 * EPS_SMALL : ( i == nYStep ? - 10 * EPS_SMALL : 0.)) ;
ptStart.Set( ptMin.x - EXP_LEN, ptMin.y + dShift + i * dYStep, ptMin.z + dDimZ) ;
}
if ( IsNull( pLine) || ! pLine->SetPVL( ptStart, X_AX, dDimX + 2 * EXP_LEN))
@@ -2974,10 +2971,12 @@ CalcPocketing( const ISurfFlatRegion *pSfr, double dRad, double dStep, double dA
dStep < EPS_SMALL ||
( nType != POCKET_ZIGZAG && nType != POCKET_ONEWAY && nType != POCKET_SPIRALIN && nType != POCKET_SPIRALOUT))
return false ;
vCrvCompoRes.clear() ; // pulizia vettore delle curve elementari
TYPE = nType ;
RAD = dRad ;
SMOOTH = bSmooth ;
// pulizia vettore delle curve elementari
vCrvCompoRes.clear() ;
// assegno dati di modulo
s_nType = nType ;
s_dRad = dRad ;
s_bSmooth = bSmooth ;
// calcolo delle curve elementari della superficie
switch ( nType) {
@@ -3165,7 +3164,7 @@ AdjustLinkDifferentY( const ICurve* pCrvSegPrec, const ICurve* pCrvSegSucc, cons
PtrOwner<ISurfFlatRegion> pSfrTrap_c( CloneSurfFlatRegion( pSfrTrap)) ;
if ( IsNull( pSfrTrap_c))
return false ;
if ( ! pSfrTrap->Offset( - RAD / 5, ICurve::OFF_CHAMFER))
if ( ! pSfrTrap->Offset( - s_dRad / 5, ICurve::OFF_CHAMFER))
pSfrTrap.Set( Release( pSfrTrap_c)) ;
// se il Link interseca questa regione, allora va eliminato
@@ -3250,7 +3249,7 @@ AdjustLinkZigZagInfill( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vNewCrv)
}
}
// se non ho mai trovato link non validi, lascio la curva invariata
if ( int( vIntervals.size()) == 0)
if ( vIntervals.empty())
vNewCrv.emplace_back( CloneCurveComposite( pCrvCompo)) ;
else {
// per ogni intervallo...
@@ -3272,8 +3271,8 @@ CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool
if ( pSfr == nullptr || ! pSfr->IsValid() || dStep < EPS_SMALL)
return false ;
vCrvCompoRes.clear() ;
SMOOTH = false ;
RAD = dStep * 0.5 ;
s_bSmooth = false ;
s_dRad = dStep / 2 ;
// vettore con i percorsi a ZigZag
ICRVCOMPOPOVECTOR vpCrvs ;
@@ -3293,7 +3292,7 @@ CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool
for ( int u = 0 ; u < int( vpCrvs.size()) ; ++ u)
vCrvFinal.emplace_back( Release( vpCrvs[u])) ;
vpCrvs.clear() ;
// sistemo le curve ottenute, aggiustando i Links
// sistemo le curve ottenute, aggiustando i Links
for ( int u = 0 ; u < int( vCrvFinal.size()) ; ++ u) {
ICRVCOMPOPOVECTOR vNewCrv ;
if ( ! AdjustLinkZigZagInfill( vCrvFinal[u], vNewCrv))
@@ -3306,12 +3305,12 @@ CalcZigZagInfill( const ISurfFlatRegion* pSfr, double dStep, bool bSmooth, bool
// inserisco i percorsi da ritornare
for ( int u = 0 ; u < int( vpCrvs.size()) ; ++ u) {
if ( bSmooth) {
SMOOTH = true ;
ModifyCurveToSmoothed( vpCrvs[u], RAD / 16, RAD / 16, false) ;
s_bSmooth = true ;
ModifyCurveToSmoothed( vpCrvs[u], s_dRad / 16, s_dRad / 16, false) ;
}
vCrvCompoRes.emplace_back( Release( vpCrvs[u])) ;
}
}
return true ;
}
}