diff --git a/Tool.cpp b/Tool.cpp index 7959901..36eef84 100644 --- a/Tool.cpp +++ b/Tool.cpp @@ -666,6 +666,92 @@ Tool::SetChiselTool( const string& sToolName, double dH, double dW, double dTh, } //---------------------------------------------------------------------------- +//bool +//Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, double dRC, int nToolNum) +//{ +// // Impostazioni generali +// m_sName = sToolName ; +// m_nCurrentNum = nToolNum ; +// m_nType = UNDEF ; +// m_Outline.Clear() ; +// m_ArcLineApprox.Clear() ; +// +// // verifica sulle minime dimensioni globali +// if ( dH < EPS_SMALL || dR < EPS_SMALL || dRC < - EPS_SMALL) +// return false ; +// +// m_nType = ADDITIVE ; +// m_dHeight = dH ; +// m_dRadius = dR ; +// m_dRCorner = dRC ; +// m_dTipHeight = 0 ; +// m_dTipRadius = 0 ; +// m_dRefRadius = 0 ; +// m_dCutterHeight = dH ; +// +// double dSquareCornerRadProj = m_dRCorner * m_dRCorner - 0.25 * m_dHeight * m_dHeight ; +// // Utensile sfiancato +// if ( dSquareCornerRadProj > 0) { +// double dCenX = m_dRadius - m_dRCorner ; +// double dCylRad = dCenX + sqrt( dSquareCornerRadProj) ; +// // Utensile mal definito +// if ( dCylRad < EPS_SMALL) +// return false ; +// // Profilo +// m_Outline.AddPoint( Point3d( 0, 0, 0)) ; +// m_Outline.AddLine( Point3d( dCylRad, 0, 0)) ; +// m_Outline.SetCurveTempProp( 0, 1, 1) ; +// CurveArc cvArc ; +// cvArc.SetC2P( Point3d( dCenX, - 0.5 * m_dHeight, 0), Point3d( dCylRad, 0, 0), Point3d( dCylRad, - m_dHeight, 0)) ; +// m_Outline.AddCurve( cvArc) ; +// m_Outline.SetCurveTempProp( 1, 1, 1) ; +// m_Outline.AddLine( Point3d( 0, - m_dHeight, 0)) ; +// m_Outline.SetCurveTempProp( 2, 1, 1) ; +// m_Outline.SetTempProp( 1, 1) ; +// } +// // Utensile cilindrico con eventuale raggio corner +// else { +// // Utensile mal definito +// if ( m_dRadius - m_dRCorner < EPS_SMALL) +// return false ; +// // Raggio corner nullo +// if ( m_dRadius < EPS_SMALL) { +// // Profilo +// m_Outline.AddPoint( Point3d( 0, 0, 0)) ; +// m_Outline.AddLine( Point3d( m_dRadius, 0, 0)) ; +// m_Outline.SetCurveTempProp( 0, 1, 1) ; +// m_Outline.AddLine( Point3d( m_dRadius, - m_dHeight, 0)) ; +// m_Outline.SetCurveTempProp( 1, 1, 1) ; +// m_Outline.AddLine( Point3d( 0, - m_dHeight, 0)) ; +// m_Outline.SetCurveTempProp( 2, 1, 1) ; +// } +// else { +// // Profilo +// m_Outline.AddPoint( Point3d( 0, 0, 0)) ; +// m_Outline.AddLine( Point3d( m_dRadius - m_dRCorner, 0, 0)) ; +// m_Outline.SetCurveTempProp( 0, 1, 1) ; +// CurveArc cvArc ; +// cvArc.SetC2P( Point3d( m_dRadius - m_dRCorner, - m_dRCorner, 0), Point3d( m_dRadius - m_dRCorner, 0, 0), Point3d( m_dRadius, - m_dRCorner, 0)) ; +// m_Outline.SetCurveTempProp( 1, 1, 1) ; +// m_Outline.AddLine( Point3d( m_dRadius, - m_dHeight + m_dRCorner, 0)) ; +// m_Outline.SetCurveTempProp( 2, 1, 1) ; +// cvArc.SetC2P( Point3d( m_dRadius - m_dRCorner, - m_dHeight + m_dRCorner, 0), Point3d( m_dRadius, - m_dHeight + m_dRCorner, 0), Point3d( m_dRadius - m_dRCorner, - m_dHeight, 0)) ; +// m_Outline.AddCurve( cvArc) ; +// m_Outline.SetCurveTempProp( 3, 1, 1) ; +// m_Outline.AddLine( Point3d( 0, - m_dHeight, 0)) ; +// m_Outline.SetCurveTempProp( 4, 1, 1) ; +// m_Outline.SetTempProp( 1, 1) ; +// } +// } +// +// //return SetGenTool( sToolName, &m_Outline, nToolNum) ; +// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// //////////////////////////////////////// Per test additivi ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// bool bOk = SetGenTool( sToolName, &m_Outline, nToolNum) ; +// m_nType = ADDITIVE ; +// return bOk ; +// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//} bool Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, double dRC, int nToolNum) { @@ -689,13 +775,15 @@ Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, doubl m_dRefRadius = 0 ; m_dCutterHeight = dH ; + bool bToolDefined = true ; + double dSquareCornerRadProj = m_dRCorner * m_dRCorner - 0.25 * m_dHeight * m_dHeight ; // Utensile sfiancato if ( dSquareCornerRadProj > 0) { double dCenX = m_dRadius - m_dRCorner ; double dCylRad = dCenX + sqrt( dSquareCornerRadProj) ; // Utensile mal definito - if ( dCylRad < 0) + if ( dCylRad < EPS_SMALL) return false ; // Profilo m_Outline.AddPoint( Point3d( 0, 0, 0)) ; @@ -708,6 +796,7 @@ Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, doubl m_Outline.AddLine( Point3d( 0, - m_dHeight, 0)) ; m_Outline.SetCurveTempProp( 2, 1, 1) ; m_Outline.SetTempProp( 1, 1) ; + bToolDefined = SetGenTool( sToolName, &m_Outline, nToolNum) ; } // Utensile cilindrico con eventuale raggio corner else { @@ -716,14 +805,7 @@ Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, doubl return false ; // Raggio corner nullo if ( m_dRadius < EPS_SMALL) { - // Profilo - m_Outline.AddPoint( Point3d( 0, 0, 0)) ; - m_Outline.AddLine( Point3d( m_dRadius, 0, 0)) ; - m_Outline.SetCurveTempProp( 0, 1, 1) ; - m_Outline.AddLine( Point3d( m_dRadius, - m_dHeight, 0)) ; - m_Outline.SetCurveTempProp( 1, 1, 1) ; - m_Outline.AddLine( Point3d( 0, - m_dHeight, 0)) ; - m_Outline.SetCurveTempProp( 2, 1, 1) ; + ; } else { // Profilo @@ -741,14 +823,10 @@ Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, doubl m_Outline.AddLine( Point3d( 0, - m_dHeight, 0)) ; m_Outline.SetCurveTempProp( 4, 1, 1) ; m_Outline.SetTempProp( 1, 1) ; + bToolDefined = SetGenTool( sToolName, &m_Outline, nToolNum) ; } } - //return SetGenTool( sToolName, &m_Outline, nToolNum) ; - ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - //////////////////////////////////////// Per test additivi ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - bool bOk = SetGenTool( sToolName, &m_Outline, nToolNum) ; m_nType = ADDITIVE ; - return bOk; - ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + return bToolDefined ; } \ No newline at end of file diff --git a/VolZmap.h b/VolZmap.h index 0d8ad94..8f03eca 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -338,8 +338,9 @@ class VolZmap : public IVolZmap, public IGeoObjRW bool SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dRad, double dHei, bool bOuterCutter) ; // Additivo - bool AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx/*, double dHei, double dRad, double dCornerRad*/) ; - + bool AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx) ; + bool AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dHei, double dRad) ; + bool AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dHei, double dMaxRad, double dMinRad) ; // Intersezioni bool IntersLineZMapLattice( const Point3d& ptP, const Vector3d& vtV, double& dU1, double& dU2) const ; diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index b06ca0f..4978fb6 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -7805,13 +7805,134 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3 //---------------------------------------------------------------------------- bool -VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx/*, double dHei, double dRad, double dCornerRad*/) +VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx) { // Dimensioni lineari dell'utensile double dHei = m_vTool[m_nCurrTool].GetHeigth() ; double dRad = m_vTool[m_nCurrTool].GetRadius() ; double dCornerRad = m_vTool[m_nCurrTool].GetCornRadius() ; + if ( dCornerRad < EPS_SMALL) { + AddingCylinder( nGrid, ptS, ptE, vtAx, dHei, dRad) ; + } + else { + ; + } + return true ; +} + +//---------------------------------------------------------------------------- +bool +VolZmap::AddingGeneral( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) +{ + //// Descrizione geometrica del moto + // Point3d ptI = ptS ; + // Point3d ptF = ptE ; + // Vector3d vtMove = ptE - ptS ; + //// Vettore delle normali agli archi + // const VCT3DVECTOR& vArcNorm = m_vTool[m_nCurrTool].GetArcNormalVec() ; + //// Poinch� l'asse utensile � parallelo all'asse Z, definisco un sistema di + //// riferimento ad hoc in cui le normali agli archi giacciano nel piano XZ. + // Frame3d frNormFrame ; + // frNormFrame.Set( ORIG, X_AX, -Z_AX, Y_AX) ; + //// Ciclo sulle curve del profilo + // const CurveComposite& ToolProfile = m_vTool[m_nCurrTool].GetApproxOutline() ; + // int i = - 1 ; + // const ICurve* pPrevCurve = nullptr ; + // const ICurve* pCurve = ToolProfile.GetCurve( ++ i) ; + // while ( pCurve != nullptr) { + // + // double dHeight = 0 ; + // // Se segmento + // if ( pCurve->GetType() == CRV_LINE) { + // // Recupero gli estremi + // const ICurveLine* pLine = GetCurveLine( pCurve) ; + // Point3d ptStart = pLine->GetStart() ; + // Point3d ptEnd = pLine->GetEnd() ; + // int nNormNum = pLine->GetTempProp(); + // Vector3d vtNormSt, vtNormEn; + // if ( nNormNum != 0) { + // vtNormSt = vArcNorm[nNormNum - 1] ; + // vtNormEn = vArcNorm[nNormNum] ; + // vtNormSt.ToLoc(frNormFrame); + // vtNormEn.ToLoc(frNormFrame); + // } + // // Ne determino l'altezza + // dHeight = ptStart.y - ptEnd.y ; + // if ( dHeight > EPS_SMALL) { + // // verifiche curva precedente per eventuale tappo sopra + // if ( pPrevCurve != nullptr && pPrevCurve->GetType() == CRV_LINE) { + // const ICurveLine* pOthLine = GetCurveLine( pPrevCurve) ; + // Point3d ptOthStart = pOthLine->GetStart() ; + // Point3d ptOthEnd = pOthLine->GetEnd() ; + // } + // // verifiche curva successiva per eventuale tappo sotto + // int j = i ; + // const ICurve* pNextCurve = ToolProfile.GetCurve( ++ j) ; + // if ( pNextCurve != nullptr && pNextCurve->GetType() == CRV_LINE) { + // const ICurveLine* pOthLine = GetCurveLine( pNextCurve) ; + // Point3d ptOthStart = pOthLine->GetStart() ; + // Point3d ptOthEnd = pOthLine->GetEnd() ; + // } + // // Se X costante, � un cilindro + // if ( abs( ptStart.x - ptEnd.x) < EPS_SMALL) { + // double dRadius = ptStart.x ; + // if ( dRadius > 10 * EPS_SMALL) { + // CompCyl_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius, bTapB, bTapT) ; + // } + // } + // // Se X crescente, � un cono con vettore equiverso a quello dell'utensile + // else if ( ptStart.x > ptEnd.x) { + // double dMaxRad = ptStart.x ; + // double dMinRad = ptEnd.x ; + // CompConus_Milling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad, bTapB, bTapT, vtNormSt, vtNormEn) ; + // } + // // Se X decrescente, � un cono con vettore opposto a quello dell'utensile + // else if ( ptStart.x < ptEnd.x) { + // double dMaxRad = ptEnd.x ; + // double dMinRad = ptStart.x ; + // Point3d ptIn = ptI - vtToolDir * dSignedHeight ; + // Point3d ptFn = ptIn + vtMove ; + // vtNormEn.z *= -1 ; + // vtNormSt.z *= -1 ; + // CompConus_Milling( nGrid, ptIn, ptFn, - vtToolDir, dHeight, dMaxRad, dMinRad, bTapT, bTapB, vtNormEn, vtNormSt) ; + // } + // } + // } + + // // Se arco + // else if ( pCurve->GetType() == CRV_ARC) { + // // Recupero estremi, centro e raggio + // const ICurveArc* pArc = GetCurveArc( pCurve) ; + // Point3d ptStart ; pArc->GetStartPoint( ptStart) ; + // Point3d ptEnd ; pArc->GetEndPoint( ptEnd) ; + // Point3d ptCen = pArc->GetCenter() ; + // double dRadius = pArc->GetRadius() ; + // // Determino le posizioni iniziale e finale del centro della sfera + // Point3d ptCenS = ptI - vtToolDir * ( ptStart.y - ptCen.y) ; + // Point3d ptCenE = ptCenS + vtMove ; + // // Eseguo l'asportazione del materiale + // CompBall_Milling( nGrid, ptCenS, ptCenE, dRadius) ; + // // aggiorno l'altezza + // //dHeight = abs( ptStart.y - ptEnd.y) ; + // } + + // // Determino le posizioni iniziale e finale del componente successivo + // ptI = ptI - vtToolDir * dSignedHeight ; + // ptF = ptI + vtMove ; + + // // Passo alla curva successiva + // pPrevCurve = pCurve ; + // pCurve = ToolProfile.GetCurve( ++ i) ; + // } + + // return true ; +} + +//---------------------------------------------------------------------------- +bool +VolZmap::AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dHei, double dRad) +{ // Verifica sull'interferenza utensile Zmap int nStartI, nStartJ, nEndI, nEndJ ; if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) @@ -7821,162 +7942,438 @@ VolZmap::AddingMotion( int nGrid, const Point3d& ptS, const Point3d& ptE, const double dLen1 = vtV1.Len() ; vtV1 /= dLen1 ; - if ( dCornerRad < EPS_SMALL) { - - if ( nGrid == 0) { - - Vector3d vtV2 = Z_AX ^ vtV1 ; - - for ( int i = nStartI ; i <= nEndI ; ++ i) { - for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - - Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ; - Vector3d vtEnC = vtStC - dLen1 * vtV1 ; - - double dX1 = vtStC * vtV1 ; - double dX2 = vtStC * vtV2 ; - - if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad + EPS_SMALL) || - vtStC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL || - vtEnC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL) { - AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, - Z_AX, Z_AX) ; - } - } - } - } - else { - double dMyTol = 0/*EPS_SMALL*/; - Frame3d CylFrame, PolyFrame ; - CylFrame.Set( ptS - dHei * vtAx, vtAx) ; - PolyFrame.Set( ptS - ( dHei + dMyTol) * vtAx, vtV1, vtAx ^ vtV1, vtAx) ; - for ( int i = nStartI ; i <= nEndI ; ++ i) { - for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - - Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; - - Point3d ptInt1, ptInt2 ; - Vector3d vtN1, vtN2 ; - - if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true, - ptInt1, vtN1, ptInt2, vtN2)) { - AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ; - } - - if ( IntersLineCylinder( ptC - dLen1 * vtV1, Z_AX, CylFrame, dHei, dRad, true, true, - ptInt1, vtN1, ptInt2, vtN2)) { - AddIntervals( nGrid, i, j, ptInt1.z + dLen1 * vtV1.z, ptInt2.z + dLen1 * vtV1.z, - vtN1, - vtN2) ; - } - - if ( IntersLineMyPolyhedron( ptC, Z_AX, PolyFrame, dLen1, 2 * ( dRad + dMyTol), dHei + 2 * dMyTol, 0, - ptInt1, vtN1, ptInt2, vtN2, false)) { - AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ; - } - } - } - } - } - else { - ; - } - return true ; - - /* if ( nGrid == 0) { - Vector3d vtV1 = ptE - ptS ; - double dLen1 = vtV1.Len() ; - vtV1 / dLen1 ; Vector3d vtV2 = Z_AX ^ vtV1 ; - double dSqareCornerRadProj = dCornerRad * dCornerRad - 0.25 * dHei * dHei ; + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - if ( dSqareCornerRadProj > 0) { - double dCylRad = dRad - dCornerRad + sqrt( dSquareCornerRadProj) ; - // Ciclo sui punti - for ( int i = nStartI ; i <= nEndI ; ++ i) { - for ( int j = nStartJ ; j <= nEndJ ; ++ j) { + Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ; + Vector3d vtEnC = vtStC - dLen1 * vtV1 ; - Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ; - Vector3d vtEnC = vtStC - dLen1 * vtV1 ; + double dX1 = vtStC * vtV1 ; + double dX2 = vtStC * vtV2 ; - double dX1 = vtC * vtV1 ; - double dX2 = vtC * vtV2 ; - - if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dCylRad) || - vtStC.SqLen() < dCylRad * dCylRad || - vtEnC.SqLen() < dCylRad * dCylRad) { - AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, Z_AX, - Z_AX) ; - } - else if ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad) { - double dr = dCornerRad - ( dRad - abs( dX2)) ; - double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ; - Vector3d vtMinN = ( dX2 > 0 ? - dr : dr) * vtV2 + Vector3d( 0, 0, dDeltaH) ; - Vector3d vtMaxN = ( dX2 > 0 ? - dr : dr) * vtV2 - Vector3d( 0, 0, dDeltaH) ; - vtMinN.Normalize() ; - vtMaxN.Normalize() ; - AddIntervals( nGrid, i, j, ptS.z - 0.5 * dHei - dDeltaH, ptS.z - 0.5 * dHei + dDeltaH, vtMinN, vtMaxN) ; - } - else if ( vtStC.SqLen() < dRad * dRad || vtEnC.SqLen() < dRad * dRad) { - Vector3d vtR = dX1 > 0 ? vtEnC : vtStC ; - double dLenR = vtR.Len() ; - vtR /= dLenR ; - double dr = dCornerRad - ( dRad - dLenR) ; - double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ; - Vector3d vtMinN = - dr * vtR + Vector3d( 0, 0, dDeltaH) ; - Vector3d vtMaxN = - dr * vtR - Vector3d( 0, 0, dDeltaH) ; - vtMinN.Normalize() ; - vtMaxN.Normalize() ; - AddIntervals( nGrid, i, j, ptS.z - 0.5 * dHei - dDeltaH, ptS.z - 0.5 * dHei + dDeltaH, vtMinN, vtMaxN) ; - } - } - } - } - else { - double dCylRad = dRad - dCornerRad ; - // Ciclo sui punti - for ( int i = nStartI ; i <= nEndI ; ++ i) { - for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - - Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ; - Vector3d vtEnC = vtStC - dLen1 * vtV1 ; - - double dX1 = vtC * vtV1 ; - double dX2 = vtC * vtV2 ; - - if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dCylRad) || - vtStC.SqLen() < dCylRad * dCylRad || - vtEnC.SqLen() < dCylRad * dCylRad) { - AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, Z_AX, - Z_AX) ; - } - else if ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad) { - double dr = abs( dX2) - dCylRad ; - double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ; - Vector3d vtMinN = ( dX2 > 0 ? - dr : dr) * vtV2 + Vector3d( 0, 0, dDeltaH) ; - Vector3d vtMaxN = ( dX2 > 0 ? - dr : dr) * vtV2 - Vector3d( 0, 0, dDeltaH) ; - vtMinN.Normalize() ; - vtMaxN.Normalize() ; - AddIntervals( nGrid, i, j, ptS.z - dHei + dCornerRad - dDeltaH, ptS.z - dCornerRad + dDeltaH, vtMinN, vtMaxN) ; - } - else if ( vtStC.SqLen() < dRad * dRad || vtEnC.SqLen() < dRad * dRad) { - Vector3d vtR = dX1 > 0 ? vtEnC : vtStC ; - double dLenR = vtR.Len() ; - vtR /= dLenR ; - double dr = dLenR - dCylRad) ; - double dDeltaH = sqrt( max( dCornerRad * dCornerRad - dr * dr, 0)) ; - Vector3d vtMinN = - dr * vtR + Vector3d( 0, 0, dDeltaH) ; - Vector3d vtMaxN = - dr * vtR - Vector3d( 0, 0, dDeltaH) ; - vtMinN.Normalize() ; - vtMaxN.Normalize() ; - AddIntervals( nGrid, i, j, ptS.z - dHei + dCornerRad - dDeltaH, ptS.z - dCornerRad + dDeltaH, vtMinN, vtMaxN) ; - } - } + if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad + EPS_SMALL) || + vtStC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL || + vtEnC.SqLen() < dRad * dRad + 2 * dRad * EPS_SMALL) { + AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, - Z_AX, Z_AX) ; + } } } } else { - ; + double dMyTol = 0/*EPS_SMALL*/; + Frame3d CylFrame, PolyFrame ; + CylFrame.Set( ptS - dHei * vtAx, vtAx) ; + PolyFrame.Set( ptS - ( dHei + dMyTol) * vtAx, vtV1, vtAx ^ vtV1, vtAx) ; + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { + + Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; + + Point3d ptInt1, ptInt2 ; + Vector3d vtN1, vtN2 ; + + if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true, + ptInt1, vtN1, ptInt2, vtN2)) { + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ; + } + + if ( IntersLineCylinder( ptC - dLen1 * vtV1, Z_AX, CylFrame, dHei, dRad, true, true, + ptInt1, vtN1, ptInt2, vtN2)) { + AddIntervals( nGrid, i, j, ptInt1.z + dLen1 * vtV1.z, ptInt2.z + dLen1 * vtV1.z, - vtN1, - vtN2) ; + } + + if ( IntersLineMyPolyhedron( ptC, Z_AX, PolyFrame, dLen1, 2 * ( dRad + dMyTol), dHei + 2 * dMyTol, 0, + ptInt1, vtN1, ptInt2, vtN2, false)) { + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ; + } + } + } + } + return true +} + +//---------------------------------------------------------------------------- +bool +VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, + double dHei, double dMaxRad, double dMinRad, + const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR) +{ + // Verifico interferenza + int nStartI, nStartJ, nEndI, nEndJ ; + if ( ! TestCompoBBox( nGrid, ptS, ptE, vtToolDir, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) + return true ; + + // Geometria del cono + double dDeltaR = dMaxRad - dMinRad ; + + // Studio simmetrie + Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ; + Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ; + + double dL = ( dMaxRad * dHei) / dDeltaR ; + double dl = dL - dHei ; + + Point3d ptV = ptI - vtToolDir * dL ; + + // Vettori caratteristici del movimento + Vector3d vtMove = ptF - ptI ; + Vector3d vtMvLong = ( vtMove * vtToolDir) * vtToolDir ; + Vector3d vtMvOrt = vtMove - vtMvLong ; + + // Terna destrorsa e unitaria + Vector3d vtV1 = vtToolDir ; + Vector3d vtV2 = vtMvOrt ; vtV2.Normalize() ; + Vector3d vtV3 = vtV1 ^ vtV2 ; + + // Sistema di riferimento intrinseco del movimento + Frame3d ConusFrame ; ConusFrame.Set( ptV, vtV2, vtV3, vtV1) ; + + // Dimensioni lineari movimento + double dLongLen = vtMvLong.Len() ; + double dOrtLen = vtMvOrt.Len() ; + + // Apertura del cono + double dTan = dDeltaR / dHei ; + double dRatio = dLongLen / dOrtLen ; + + // Per costruire piani laterali poliedro interno + double dCos = dTan * dRatio ; + double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + + // Dimensioni lineari descriventi il poliedro interno + double dLenX = dLongLen ; + double dLenY = dOrtLen ; + double dLenZ = dSin * dMinRad ; + double dDeltaX = dHei ; + double dDeltaY = dCos * dDeltaR ; + double dDeltaZ = dSin * dDeltaR ; + + // Sistema di riferimento poliedro + Point3d ptO = ptV + vtV1 * dl + vtV2 * ( dCos * dMinRad) ; + Frame3d PolyFrame ; + PolyFrame.Set( ptO, vtV1, vtV2, vtV3) ; + + // Versori piani nel riferimento poliedro ( riferiti al sistema di riferimento) : + // Sx, Dx + Vector3d vtNs( - dTan, dCos, dSin) ; + vtNs.Normalize() ; + Vector3d vtNd( - dTan, dCos, - dSin) ; + vtNd.Normalize() ; + // Iniziale e finale + Vector3d vtIF( - dDeltaY, dDeltaX, 0) ; + vtIF.Normalize() ; + // Up e Down + Vector3d vtUD( - dLenY, dLenX, 0) ; + vtUD.Normalize() ; + + // Punti dei piani (sempre espressi nel sistema PolyFrame) + Point3d ptFacet135( 0, 0, dLenZ) ; + Point3d ptFacet246( dLenX + dDeltaX, dLenY + dDeltaY, - dLenZ - dDeltaZ) ; + + Vector3d vtUmv = vtMove ; vtUmv.Normalize() ; + + if ( dRatio * dTan <= 1) { + + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { + + Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; + + Point3d ptInt1, ptInt2 ; + Vector3d vtN1, vtN2 ; + + // Cono iniziale + ConusFrame.ChangeOrig( ptV) ; + if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) { + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) { + Vector3d vtL1 = ptInt1 - ptV ; + vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ; + double dL1 = vtL1.Len() ; + vtL1 /= dL1 ; + Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR; + vtOriginalN1.Normalize() ; + vtN1 = vtOriginalN1.z * vtToolDir + vtOriginalN1.x * vtL1 ; + vtN1.Normalize() ; + } + if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) { + Vector3d vtL2 = ptInt2 - ptV ; + vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ; + double dL2 = vtL2.Len() ; + vtL2 /= dL2 ; + Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN2.Normalize() ; + vtN2 = vtOriginalN2.z * vtToolDir + vtOriginalN2.x * vtL2 ; + vtN2.Normalize() ; + } + } + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + + // Cono finale + ConusFrame.ChangeOrig( ptV + vtMove) ; + if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) { + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) { + Vector3d vtL1 = ptInt1 - ptV - vtMove ; + vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ; + double dL1 = vtL1.Len() ; + vtL1 /= dL1 ; + Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN1.Normalize() ; + vtN1 = vtOriginalN1.z * vtToolDir + vtOriginalN1.x * vtL1 ; + vtN1.Normalize() ; + } + if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtToolDir, 0.1 * EPS_SMALL)) { + Vector3d vtL2 = ptInt2 - ptV - vtMove ; + vtL2 -= (vtL2 * vtToolDir) * vtToolDir; + double dL2 = vtL2.Len() ; + vtL2 /= dL2 ; + Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN2.Normalize() ; + vtN2 = vtOriginalN2.z * vtToolDir + vtOriginalN2.x * vtL2 ; + vtN2.Normalize() ; + } + } + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + + // Solido interno + Point3d ptPoly = ptC ; + Vector3d vtPoly = Z_AX ; + + ptPoly.ToLoc( PolyFrame) ; + vtPoly.ToLoc( PolyFrame) ; + + Point3d ptPoly1 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtNs) / ( vtPoly * vtNs)) * vtPoly ; + Point3d ptPoly2 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtNd) / ( vtPoly * vtNd)) * vtPoly ; + Point3d ptPoly3 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ; + Point3d ptPoly4 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ; + Point3d ptPoly5 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ; + Point3d ptPoly6 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ; + + int nIntNum = 0 ; + + // Intersezione con la prima faccia + if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) { + if ( dLenY * ptPoly1.x >= dLenX * ptPoly1.y && + dLenY * ( ptPoly1.x - dDeltaX) <= dLenX * ( ptPoly1.y - dDeltaY) && + dDeltaX * ptPoly1.y >= dDeltaY * ptPoly1.x && + dDeltaX * ( ptPoly1.y - dLenY) <= dDeltaY * ( ptPoly1.x - dLenX)) { + ptInt1 = ptPoly1 ; + vtN1 = - vtNs ; + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + Vector3d vtRadial( 0, dMinRad * dCos, dMinRad * dSin) ; + vtRadial.Normalize() ; + Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; + Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; + vtOrigMaxR.Normalize() ; + vtOrigMinR.Normalize() ; + vtN1 = - ( ( dDeltaZ - ptInt1.z + dLenZ) / dDeltaZ) * vtOrigMinR - ( ( ptInt1.z - dLenZ) / dDeltaZ) * vtOrigMaxR ; + vtN1.Normalize() ; + } + ++ nIntNum ; + } + } + // Intersezione con la seconda faccia + if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) { + if ( dLenY * ptPoly2.x >= dLenX * ptPoly2.y && + dLenY * ( ptPoly2.x - dDeltaX) <= dLenX * ( ptPoly2.y - dDeltaY) && + dDeltaX * ptPoly2.y >= dDeltaY * ptPoly2.x && + dDeltaX * ( ptPoly2.y - dLenY) <= dDeltaY * ( ptPoly2.x - dLenX)) { + + if ( nIntNum == 0) { + ptInt1 = ptPoly2 ; + vtN1 = - vtNd ; + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + Vector3d vtRadial( 0, dMinRad * dCos, - dMinRad * dSin) ; + vtRadial.Normalize() ; + Vector3d vtOrigMaxR = - vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; + Vector3d vtOrigMinR = - vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; + vtOrigMaxR.Normalize() ; + vtOrigMinR.Normalize() ; + vtN1 = - ( ( dDeltaZ - abs( ptInt1.z) + dLenZ) / dDeltaZ) * vtOrigMinR - ( ( abs( ptInt1.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ; + vtN1.Normalize() ; + } + ++ nIntNum ; + } + else if ( ( ptInt1 - ptPoly2).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly2 ; + vtN2 = - vtNd ; + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + Vector3d vtRadial( 0, dMinRad * dCos, -dMinRad * dSin) ; + vtRadial.Normalize() ; + Vector3d vtOrigMaxR = -vtArcNormMaxR.x * vtRadial - vtArcNormMaxR.z * X_AX ; + Vector3d vtOrigMinR = -vtArcNormMinR.x * vtRadial - vtArcNormMinR.z * X_AX ; + vtOrigMaxR.Normalize() ; + vtOrigMinR.Normalize() ; + vtN2 = - ( ( dDeltaZ - abs( ptInt2.z) + dLenZ) / dDeltaZ) * vtOrigMinR - ( ( abs( ptInt2.z) - dLenZ) / dDeltaZ) * vtOrigMaxR ; + vtN2.Normalize() ; + } + ++ nIntNum ; + } + } + } + // Intersezione con la terza faccia + if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { + if ( nIntNum < 2 && + ptPoly3.x >= 0 && ptPoly3.x <= dDeltaX && + dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x) { + + if ( nIntNum == 0) { + ptInt1 = ptPoly3 ; + vtN1 = - vtIF ; + ++ nIntNum ; + } + else if ( ( ptInt1 - ptPoly3).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly3 ; + vtN2 = - vtIF ; + ++ nIntNum ; + } + } + } + + // Intersezione con la quarta faccia + if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { + if ( nIntNum < 2 && + ptPoly4.x >= dLenX && ptPoly4.x <= dLenX + dDeltaX && + dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX)) { + + if ( nIntNum == 0) { + ptInt1 = ptPoly4 ; + vtN1 = vtIF ; + ++ nIntNum ; + } + else if ( ( ptInt1 - ptPoly4).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly4 ; + vtN2 = vtIF ; + ++ nIntNum ; + } + } + } + + // Intersezione con la quinta faccia + if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) { + if ( nIntNum < 2 && + ptPoly5.y >= 0 && ptPoly5.y <= dLenY && + abs( ptPoly5.z) <= dLenZ) { + + if ( nIntNum == 0) { + ptInt1 = ptPoly5 ; + vtN1 = vtUD ; + ++ nIntNum ; + } + else if ( ( ptInt1 - ptPoly5).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly5 ; + vtN2 = vtUD ; + ++ nIntNum ; + } + } + } + + // Intersezione con la sesta faccia + if ( abs( vtPoly * vtUD) > COS_ORTO_ANG_ZERO) { + if ( nIntNum < 2 && + ptPoly6.y >= dDeltaY && ptPoly6.y <= dLenY + dDeltaY && + abs( ptPoly6.z) <= dLenZ + dDeltaZ) { + + if ( nIntNum == 0) { + ptInt1 = ptPoly6; + vtN1 = - vtUD ; + ++ nIntNum ; + } + else if ( ( ptInt1 - ptPoly6).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly6; + vtN2 = - vtUD ; + ++ nIntNum ; + } + } + } + // Se il poliedro � attraversato taglio + if ( nIntNum == 2) { + + // Riporto le intersezioni nel sistema griglia + ptInt1.ToGlob( PolyFrame) ; + vtN1.ToGlob( PolyFrame) ; + ptInt2.ToGlob( PolyFrame) ; + vtN2.ToGlob( PolyFrame) ; + + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + + // Se movimento non ortogonale all'asse sottraggo i cilindri ellittici + if ( dLongLen > EPS_SMALL) { + + // Traslazione ellisse di punta + ConusFrame.ChangeOrig( ptV + vtV1 * dl) ; + if ( IntersLineEllipticalCylinder( ptC, Z_AX, ConusFrame, dMinRad, dLongLen, dOrtLen, + true, true, ptInt1, vtN1, ptInt2, vtN2)) { + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + + // Traslazione ellisse di base + ConusFrame.ChangeOrig( ptV + vtV1 * dL) ; + if ( IntersLineEllipticalCylinder( ptC, Z_AX, ConusFrame, dMaxRad, dLongLen, dOrtLen, + true, true, ptInt1, vtN1, ptInt2, vtN2)) { + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + } + } + } + return true ; + } + + else { + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { + + Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ; + + Point3d ptInt1, ptInt2 ; + Vector3d vtN1, vtN2 ; + + // Cono + ConusFrame.ChangeOrig( ptV) ; + if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) { + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtToolDir, 0.1 * EPS_SMALL)) { + Vector3d vtL1 = ptInt1 - ptV ; + vtL1 -= ( vtL1 * vtToolDir) * vtToolDir ; + double dL1 = vtL1.Len() ; + vtL1 /= dL1 ; + Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN1.Normalize() ; + vtN1 = vtOriginalN1.z * vtToolDir + vtOriginalN1.x * vtL1 ; + vtN1.Normalize() ; + } + if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtToolDir, 0.1 * EPS_SMALL)) { + Vector3d vtL2 = ptInt2 - ptV ; + vtL2 -= ( vtL2 * vtToolDir) * vtToolDir ; + double dL2 = vtL2.Len() ; + vtL2 /= dL2 ; + Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN2.Normalize() ; + vtN2 = vtOriginalN2.z * vtToolDir + vtOriginalN2.x * vtL2 ; + vtN2.Normalize() ; + } + } + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + + // Traslazione ellisse + ConusFrame.ChangeOrig( ptV + vtV1 * dL) ; + if ( IntersLineEllipticalCylinder( ptC, Z_AX, ConusFrame, dMaxRad, dLongLen, dOrtLen, + true, true, ptInt1, vtN1, ptInt2, vtN2)) { + AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; + } + } + } + return true ; } - */ } // ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------