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

Virtual milling additivo

Browse Source
This commit is contained in:
LorenzoM
2022-01-05 15:46:40 +01:00
parent 33547de67a
commit 2bb59366a3
3 changed files with 187 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
VolZmapVolume.cpp
+153 -83
View File
@@ -263,18 +263,22 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
if ( nGrid < 0 || nGrid > 2)
return false ;
// Controllo che dMin < dMax
if ( dMin > dMax)
swap( dMin, dMax) ;
// Controllo che indici nI, nJ siano entro i limiti
if ( nI < 0 && nI >= m_nNx[nGrid] &&
nJ < 0 && nJ >= m_nNy[nGrid])
return false ;
// Riporto le coordinate cicliche nell'ordine di partenza
// Controllo che dMin < dMax
Vector3d vtNmi = vtNMin ;
Vector3d vtNma = vtNMax ;
if ( dMin > dMax) {
swap( dMin, dMax) ;
swap( vtNmi, vtNma) ;
}
// Riporto le coordinate cicliche nell'ordine di partenza
/*Vector3d vtNmi = vtNMin ;
Vector3d vtNma = vtNMax ;*/
if ( nGrid == 1) {
swap( vtNmi.x, vtNmi.z) ;
swap( vtNmi.y, vtNmi.z) ;
@@ -5478,13 +5482,13 @@ VolZmap::IntersLineCircSweptSurfCuttedByPlanes( const Point3d& ptLineP, const Ve
// Escludo le soluzioni che non stanno dalla parte ammissibile rispetto al piano.
bool bSecIntToTest = nRoot > 1 ;
for ( int n = 0 ; n < int( vPlanesVec.size()) && nRoot > 0 ; ++ n) {
double dDist1 = DistPointPlane(ptInt1, vPlanesVec[n]);
//double dDist1 = DistPointPlane(ptInt1, vPlanesVec[n]);
if ( DistPointPlane( ptInt1, vPlanesVec[n]) > 0 + EPS_SMALL/*DistPointPlane( ptInt1, vPlanesVec[n]) >= 0*/) {
ptInt1 = ptInt2 ;
vtN1 = vtN2 ;
-- nRoot ;
}
double dDist2 = DistPointPlane(ptInt2, vPlanesVec[n]);
//double dDist2 = DistPointPlane(ptInt2, vPlanesVec[n]);
if ( bSecIntToTest && nRoot > 0 && DistPointPlane( ptInt2, vPlanesVec[n]) > 0 + EPS_SMALL/*bSecIntToTest && nRoot > 0 && DistPointPlane( ptInt2, vPlanesVec[n]) >= 0*/) {
bSecIntToTest = false ;
-- nRoot ;
@@ -6384,8 +6388,8 @@ VolZmap::SurfCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
vParAndNormIntersVec.back().second = vtN2 ;
if ( vCutEllipCylPlaneVecUp.size() == 1) {
if ( SqDist( ptInt1, ptInt2) < EPS_SMALL) {
double dLL1 = (ptInt1 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
double dLL2 = (ptInt2 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
//double dLL1 = (ptInt1 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
//double dLL2 = (ptInt2 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
if ( ( ptInt1 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN() > 0.)
vParAndNormIntersVec.erase( vParAndNormIntersVec.begin() + int( vParAndNormIntersVec.size()) - 2) ;
else if ( ( ptInt2 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN() > 0.)
@@ -6408,9 +6412,8 @@ VolZmap::SurfCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
vParAndNormIntersVec.back().second = vtN2 ;
if ( vCutEllipCylPlaneVecDw.size() == 1) {
if ( SqDist( ptInt1, ptInt2) < EPS_SMALL) {
int bazinga2 = 0 ;
double dLL1 = (ptInt1 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
double dLL2 = (ptInt2 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
//double dLL1 = (ptInt1 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
//double dLL2 = (ptInt2 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
if ( ( ptInt1 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN() > 0.)
vParAndNormIntersVec.erase( vParAndNormIntersVec.begin() + int( vParAndNormIntersVec.size()) - 2) ;
else if ( ( ptInt2 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN() > 0.)
@@ -7002,9 +7005,8 @@ VolZmap::SurfConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
vParAndNormIntersVec.back().second = vtN2 ;
if ( vCutEllipCylPlaneVecUp.size() == 1) {
if ( SqDist( ptInt1, ptInt2) < EPS_SMALL) {
int bazinga1 = 0 ;
double dLL1 = (ptInt1 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
double dLL2 = (ptInt2 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
//double dLL1 = (ptInt1 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
//double dLL2 = (ptInt2 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN();
if ( ( ptInt1 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN() > 0.)
vParAndNormIntersVec.erase( vParAndNormIntersVec.begin() + int( vParAndNormIntersVec.size()) - 2) ;
else if ( ( ptInt2 - vCutEllipCylPlaneVecUp[0].GetPoint()) * vCutEllipCylPlaneVecUp[0].GetVersN() > 0.)
@@ -7027,9 +7029,8 @@ VolZmap::SurfConus_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE, c
vParAndNormIntersVec.back().second = vtN2 ;
if ( vCutEllipCylPlaneVecDw.size() == 1) {
if ( SqDist( ptInt1, ptInt2) < EPS_SMALL) {
int bazinga2 = 0 ;
double dLL1 = (ptInt1 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
double dLL2 = (ptInt2 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
//double dLL1 = (ptInt1 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
//double dLL2 = (ptInt2 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN();
if ( ( ptInt1 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN() > 0.)
vParAndNormIntersVec.erase( vParAndNormIntersVec.begin() + int( vParAndNormIntersVec.size()) - 2) ;
else if ( ( ptInt2 - vCutEllipCylPlaneVecDw[0].GetPoint()) * vCutEllipCylPlaneVecDw[0].GetVersN() > 0.)
@@ -7680,7 +7681,6 @@ VolZmap::SurfSphericalShell_Milling( int nGrid, const Point3d& ptS, const Point3
vtPlaneN *= - 1 ;
double dC = vtDispVers * vtAx ;
double dS = sqrt( max( 1 - dC * dC, 0.)) ;
double dTempTest = (dC * dHei / dS);
Point3d ptPlaneP = ptS - dHei * vtAx + ( dC * dHei / dS) * vtOrtDispVers ;
vector<Plane3d> vEllipCylCutPlanesVec ;
vEllipCylCutPlanesVec.emplace_back() ;
@@ -7792,101 +7792,171 @@ 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/*, double dHei, double dRad, double dCornerRad*/)
{
// 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() ;
// Verifica sull'interferenza utensile Zmap
int nStartI, nStartJ, nEndI, nEndJ ;
if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dRad, dRad, dHei, nStartI, nStartJ, nEndI, nEndJ))
return true ;
Vector3d vtV1 = ptE - ptS ;
double dLen1 = vtV1.Len() ;
vtV1 / dLen1 ;
Vector3d vtV2 = Z_AX ^ vtV1 ;
if ( dCornerRad < EPS_SMALL) {
// Mappa con asse Z ortogonale al moto
if ( nGrid == 0) {
Vector3d vtV1 = ptE - ptS ;
double dLen1 = vtV1.Len() ;
vtV1 / dLen1 ;
Vector3d vtV2 = Z_AX ^ vtV1 ;
// Ciclo sui punti
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) ;
Vector3d vtStC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
Vector3d vtEnC = vtStC - dLen1 * vtV1 ;
Vector3d vtC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
double dX1 = vtStC * vtV1 ;
double dX2 = vtStC * vtV2 ;
double dX1 = vtC * vtV1 ;
double dX2 = vtC * vtV2 ;
if ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad + EPS_SMALL) {
AddIntervals(nGrid, i, j, min( ptS.z, ptS.z - vtAx.z * dHei), max( ptS.z, ptS.z - vtAx.z * dHei), -Z_AX, Z_AX) ;
}
else if ( sqrt( dX1 * dX1 + dX2 * dX2) < dRad + EPS_SMALL) {
AddIntervals(nGrid, i, j, min( ptS.z, ptS.z - vtAx.z * dHei), max( ptS.z, ptS.z - vtAx.z * dHei), -Z_AX, Z_AX) ;
}
else if ( sqrt( ( dX1 - dLen1) * ( dX1 - dLen1) + dX2 * dX2) < dRad + EPS_SMALL) {
AddIntervals(nGrid, i, j, min( ptS.z, ptS.z - vtAx.z * dHei), max( ptS.z, ptS.z - vtAx.z * dHei), -Z_AX, Z_AX) ;
}
if ( ( dX1 > 0 && dX1 < dLen1 && abs( dX2) < dRad) ||
vtStC.SqLen() < dRad * dRad ||
vtEnC.SqLen() < dRad * dRad) {
AddIntervals( nGrid, i, j, ptS.z - dHei, ptS.z, - Z_AX, Z_AX) ;
}
}
}
}
// Altre mappe
else {
Point3d ptITip = ptS - vtAx * dHei ;
// Definizione terne vettoriali e sistemi di riferimento intrinseci al movimento
Vector3d vtMove = ptE - ptS ;
Vector3d vtMoveLong = ( vtMove * vtAx) * vtAx ;
Vector3d vtMoveOrt = vtMove - vtMoveLong ;
Vector3d vtV1 = vtAx ;
Vector3d vtV2 = vtMoveOrt ; vtV2.Normalize() ;
Vector3d vtV3 = vtV1 ^ vtV2 ;
Frame3d CylFrame ; CylFrame.Set( ptITip, vtV2, vtV3, vtV1) ;
// Parametri geometrici di moto e cilindro
double dLongLen = vtMoveLong.Len() ;
double dOrtLen = vtMoveOrt.Len() ;
Frame3d CylFrame, PolyFrame ;
CylFrame.Set( ptS - dHei * vtAx, vtAx) ;
PolyFrame.Set( ptS - dHei * 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 ptC( ( i + 0.5) * m_dStep - ptS.x, ( j + 0.5) * m_dStep - ptS.y, 0) ;
Point3d ptInt1, ptInt2 ;
Vector3d vtN1, vtN2 ;
// Cilindro iniziale
CylFrame.ChangeOrig( ptITip) ;
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, 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) ;
}
// Cilindro finale:L'unica differenza rispetto a prima � l'origine
// del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
// il vettore che congiunge le due origini.
CylFrame.ChangeOrig( ptITip + vtMove) ;
if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, true, true, ptInt1, vtN1, ptInt2, vtN2)) {
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
}
// Poliedro interno
CylFrame.ChangeOrig( ptITip) ;
if ( IntersLineMyPolyhedron( ptC, Z_AX, CylFrame, dOrtLen, 2 * dRad, dHei,
dLongLen, ptInt1, vtN1, ptInt2, vtN2)) {
SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ;
if ( IntersLineMyPolyhedron( ptC - dLen1 * vtV1, Z_AX, PolyFrame, dLen1, dRad, dHei, 0,
ptInt1, vtN1, ptInt2, vtN2)) {
AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, - vtN1, - vtN2) ;
}
}
}
}
}
else {
return true ;
;
}
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 ;
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 ;
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) ;
}
}
}
}
}
else {
;
}
*/
}
// ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------