From afce50e1c8fb87e393c727574b5fd53bb6cf61a0 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Mon, 31 Oct 2016 19:22:55 +0000 Subject: [PATCH] EgtGeomKernel : - aggiunta creazione solidi Zmap per estrusione di regione. --- GdbExecutor.cpp | 42 +++++ GdbExecutor.h | 1 + VolZmap.cpp | 436 ++++++++++++++++++++++++++++++++++-------------- VolZmap.h | 3 +- 4 files changed, 353 insertions(+), 129 deletions(-) diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp index 2b206ff..fc10ca7 100644 --- a/GdbExecutor.cpp +++ b/GdbExecutor.cpp @@ -2583,21 +2583,30 @@ GdbExecutor::ExecuteVolZmap(const string& sCmd2, const STRVECTOR& vsParams) else if ( sCmd2 == "ADD") { return VolZmapIntervalsAddiction( vsParams) ; } + // se lavorazione else if ( sCmd2 == "MIL") { return VolZmapMilling( vsParams) ; } + // se settaggio utensile generico else if ( sCmd2 == "SET") { return VolZmapSetGenTool( vsParams) ; } + // se settagggio utensile di tipo predefinito else if ( sCmd2 == "SETSTD") { return VolZmapSetAdvTool( vsParams) ; } + // se misuro materiale else if ( sCmd2 == "MEASURE") { return VolZmapDeepnessMeasure( vsParams) ; } + // se intersezione BBox con Zmap aggiornato else if ( sCmd2 == "ZBOXINT") { return VolZmapBBoxZmapIntersection( vsParams) ; } + // se creazione zmap da flatregion + else if ( sCmd2 == "FLATZMAP") { + return VolZmapCreateFromFlatRegion( vsParams) ; + } return false ; } @@ -2640,6 +2649,39 @@ GdbExecutor::VolZmapCreate( const STRVECTOR& vsParams) return AddGeoObj(vsParams[0], vsParams[1], Release( pZprova)) ; } +//---------------------------------------------------------------------------- +bool +GdbExecutor::VolZmapCreateFromFlatRegion( const STRVECTOR& vsParams) +{ + // parametri : Id, IdParent, idCurv, dPrec, dLengthZ + if ( vsParams.size() != 5) + return false ; + // recupero il riferimento in cui è immerso + Frame3d frRef ; + if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef)) + return false ; + // recupero id flatregion + int nIdFlat = GetIdParam( vsParams[2]) ; + // recupero precisione + double dPrec ; + if ( ! FromString( vsParams[4], dPrec)) + return false ; + // recupero dimensioneZ + double dLengthZ ; + if ( ! FromString( vsParams[3], dLengthZ)) + return false ; + // recupero puntatore a FlatRegion + ISurfFlatRegion* pRegion = GetSurfFlatRegion( m_pGDB->GetGeoObj( nIdFlat)) ; + if ( pRegion == nullptr) + return false ; + // creo Zmap + PtrOwner pZprova( new VolZmap) ; + pZprova->CreateMapFromFlatRegion( *pRegion, dLengthZ, dPrec); + + // inserisco nel DB + return AddGeoObj(vsParams[0], vsParams[1], Release( pZprova)) ; +} + //---------------------------------------------------------------------------- bool GdbExecutor::VolZmapIntervalsSubtraction( const STRVECTOR& vsParams) diff --git a/GdbExecutor.h b/GdbExecutor.h index 844fcb1..642d39a 100644 --- a/GdbExecutor.h +++ b/GdbExecutor.h @@ -115,6 +115,7 @@ class GdbExecutor : public IGdbExecutor bool SurfTriMeshDoSewing( const STRVECTOR& vsParams) ; bool ExecuteVolZmap( const std::string& sCmd2, const STRVECTOR& vsParams) ; bool VolZmapCreate( const STRVECTOR& vsParams) ; + bool VolZmapCreateFromFlatRegion( const STRVECTOR& vsParams) ; bool VolZmapIntervalsSubtraction( const STRVECTOR& vsParams) ; bool VolZmapIntervalsAddiction( const STRVECTOR& vsParams) ; bool VolZmapMilling( const STRVECTOR& vsParams) ; diff --git a/VolZmap.cpp b/VolZmap.cpp index 3b86ac0..79a3645 100644 --- a/VolZmap.cpp +++ b/VolZmap.cpp @@ -371,15 +371,20 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double if ( dLengthX < EPS_SMALL || dLengthY < EPS_SMALL || dLengthZ < EPS_SMALL) return false ; + // Definisco il sistema di riferimento in trinseco dello Zmap m_LocalFrame.Set( ptO, X_AX, Y_AX, Z_AX) ; + // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL m_dStep = max( dPrec, 100 * EPS_SMALL) ; + // A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe + // della griglia Zmap e da questi la dimensione del vettore di dexel m_nNx = static_cast ( ceil( dLengthX / m_dStep)) ; m_nNy = static_cast ( ceil( dLengthY / m_dStep)) ; m_nDim = m_nNx * m_nNy ; + // Ridimensiono il vettore di dexel e creo lo Zmap m_ZValues.resize( m_nDim) ; for ( int i = 0 ; i < int( m_nDim) ; i++) { @@ -388,6 +393,7 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double m_ZValues[i][1] = dLengthZ ; } + // Assegno il minimo e massimo valore di Z della mappa m_dMinZ = 0 ; m_dMaxZ = dLengthZ ; @@ -395,6 +401,97 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double return true ; } +//---------------------------------------------------------------------------- +bool +VolZmap::CreateMapFromFlatRegion( const ISurfFlatRegion& Surf, double dLengthZ, double dPrec) +{ + Point3d ptMapOrig, ptMapEnd ; + + // Determino il bounding box della flat region + BBox3d SurfBBox ; + Surf.GetLocalBBox( SurfBBox, 2) ; + + // Determino i punti estremi del bounding box + SurfBBox.GetMinMax( ptMapOrig, ptMapEnd) ; + + // Sistema di riferimento mappa + m_LocalFrame.Set( ptMapOrig, X_AX, Y_AX, Z_AX) ; + + // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL + m_dStep = max( dPrec, 100 * EPS_SMALL) ; + + // Determino le dimensioni lineari X Y della griglia + double dLengthX = ptMapEnd.x - ptMapOrig.x ; + double dLengthY = ptMapEnd.y - ptMapOrig.y ; + + // A partire dalle dimensioni di xy del grezzo determino il numero di colonne e righe + // della griglia Zmap e da questi la dimensione del vettore di dexel + m_nNx = static_cast ( ceil( dLengthX / m_dStep)) ; + m_nNy = static_cast ( ceil( dLengthY / m_dStep)) ; + + m_nDim = m_nNx * m_nNy ; + + // Ridimensiono il vettore di dexel e creo lo Zmap + m_ZValues.resize( m_nDim) ; + + // Determinazione e ridimensionamento dei dexel + // interni alla regione + for( unsigned int i = 0 ; i < m_nNx ; ++ i) { + + // Definisco la retta da intersecare con la regione + double dX = ( i + 0.5) * m_dStep ; + Point3d ptP0 = ptMapOrig + Vector3d( dX, 0, 0) ; + CurveLine GridLine ; + GridLine.SetPVL( ptP0, Y_AX, dLengthY) ; + + // Determino le intersezioni della retta con la regione + CRVCVECTOR IntersectionResults ; + Surf.GetCurveClassification( GridLine, IntersectionResults) ; + // Parti di cui la retta analizzata è composta + int nPart = int( IntersectionResults.size()) ; + + // Analizzio le parti + for ( int k = 0 ; k < nPart ; ++ k) { + + // Tipo di curva + int nType = IntersectionResults[k].nClass ; + + // Se la retta è interna alla regione o coincidente con parte della sua frontiera + if ( nType == CRVC_IN || nType == CRVC_ON_P || nType == CRVC_ON_M) { + + // Parametri iniziale e finale + double dt1 = IntersectionResults[k].dParS ; + double dt2 = IntersectionResults[k].dParE ; + + // Indici corrispondenti alle coordinate dei punti + unsigned int nStartJ = static_cast ( floor( dt1 * m_nNy)) ; + unsigned int nEndJ = static_cast ( floor( dt2 * m_nNy)) ; + + nEndJ = ( nEndJ >= m_nNy ? m_nNy - 1 : nEndJ) ; + + // Ridimensiono e riempio i dexel + for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + // Determino il dexel + unsigned int nPos = j * m_nNx + i ; + + m_ZValues[nPos].resize( 2) ; + // Aggiorno le quote estreme del segmento + m_ZValues[nPos][0] = 0 ; + m_ZValues[nPos][1] = dLengthZ ; + } + } + } + } + + // Assegno il minimo e massimo valore di Z della mappa + m_dMinZ = 0 ; + m_dMaxZ = dLengthZ ; + + m_nStatus = OK ; + + return true ; +} + //---------------------------------------------------------------------------- bool VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMax) @@ -994,10 +1091,10 @@ VolZmap::SetAdvTool( const string& sToolName, double dH, double dR, //---------------------------------------------------------------------------- bool -VolZmap::SetGenTool( const string& pToolName, const ICurveComposite* pToolOutline) +VolZmap::SetGenTool( const string& sToolName, const ICurveComposite* pToolOutline) { // Aggiorno il nome dell'utensile - m_sToolName = pToolName ; + m_sToolName = sToolName ; // Aggiorno il tipo di utensile m_nToolType = GenericTool ; @@ -1017,46 +1114,60 @@ VolZmap::SetGenTool( const string& pToolName, const ICurveComposite* pToolOutlin // Se la curva è un arco valuto approssimarlo if ( pCurve->GetType() == CRV_ARC) { + // Centro e punti iniziale e finale dell'arco Point3d ptStart, ptEnd, ptO ; pCurve->GetStartPoint( ptStart) ; pCurve->GetEndPoint( ptEnd) ; pCurve->GetCenterPoint( ptO) ; + // Vettore congiungente il centro con i punti iniziale e finale Vector3d vtStRad = ptStart - ptO ; Vector3d vtEnRad = ptEnd - ptO ; + // Calcolo del raggio dell'arco double dRadius = GetBasicCurveArc( pCurve)->GetRadius() ; + // Recupero la curva precedente e quella successiva const ICurve* pPrev = m_ToolOutline.GetPrevCurve() ; const ICurve* pNext = m_ToolOutline.GetNextCurve() ; - pNext = m_ToolOutline.GetNextCurve() ; - Point3d ptPs, ptCt, ptCb, ptNe ; - Vector3d vtNPf, vtNCi, vtNCf, vtNNi ; + // Valuto la necessità di approssimare l'arco o meno + + // Punto Iniziale della curva precedente e finale della successiva + Point3d ptStartPrev, ptEndNext ; + + // Vettori tangenti alle curve precedente corrente e successiva + // rispettivamente nei punti finale, iniziale e finale e iniziale + // e prodotti vettore fra i suddetti + Vector3d vtPrevEndDir, vtCurrentStartDir, vtCurrentEndDir, vtNextStartDir ; Vector3d vtIProd, vtFProd ; - ptCt = ptO + Y_AX * dRadius ; - ptCb = ptO - Y_AX * dRadius ; + Point3d ptTopCurrent = ptO + Y_AX * dRadius ; + Point3d ptBottomCurrent = ptO - Y_AX * dRadius ; - pPrev->GetStartPoint( ptPs) ; - pPrev->GetEndDir( vtNPf) ; - pCurve->GetStartDir( vtNCi) ; - vtIProd = vtNPf ^ vtNCi ; + // Valuto le relazioni geometriche fra la + // curva corrente e quella precedente. + pPrev->GetStartPoint( ptStartPrev) ; + pPrev->GetEndDir( vtPrevEndDir) ; + pCurve->GetStartDir( vtCurrentStartDir) ; + vtIProd = vtPrevEndDir ^ vtCurrentStartDir ; + // Se la curva successiva esiste valuto le + // medesime relazioni con la quest'ultima if ( pNext != nullptr) { - pNext->GetEndPoint( ptNe) ; - pCurve->GetEndDir( vtNCf) ; - pNext->GetStartDir( vtNNi) ; - vtFProd = vtNCf ^ vtNNi ; + pNext->GetEndPoint( ptEndNext) ; + pCurve->GetEndDir( vtCurrentEndDir) ; + pNext->GetStartDir( vtNextStartDir) ; + vtFProd = vtCurrentEndDir ^ vtNextStartDir ; } // Se devo approssimare - if ( ! ( ( abs( ptO.x) < EPS_SMALL && vtIProd.z > 0 && ptPs.y > ptCt.y) && + if ( ! ( ( abs( ptO.x) < EPS_SMALL && vtIProd.z > 0 && ptStartPrev.y > ptTopCurrent.y) && ( ( pNext == nullptr && abs( ptEnd.x) < EPS_SMALL) || - ( pNext != nullptr && vtFProd.z > 0 && ptCb.y > ptNe.y)))) { + ( pNext != nullptr && vtFProd.z > 0 && ptBottomCurrent.y > ptEndNext.y)))) { // Copio la parte precedente const ICurve* pAux = m_ToolOutline.GetFirstCurve() ; @@ -1088,14 +1199,16 @@ VolZmap::SetGenTool( const string& pToolName, const ICurveComposite* pToolOutlin } // Se non deve essere approssimato else { - // Se è già stato definito m_ToolArcLineApprox deve essere completo + // Se è già stato definito m_ToolArcLineApprox deve + // essere completo, aggiungo quindi l'arco corrente if ( m_ToolArcLineApprox.GetCurveCount() != 0) m_ToolArcLineApprox.AddCurve( * pCurve, true) ; } } // Se è segmento else { - // Se è già stato definito m_ToolArcLineApprox deve essere completo + // Se è già stato definito m_ToolArcLineApprox deve + // essere completo, aggiungo quindi il segmento corrente if ( m_ToolArcLineApprox.GetCurveCount() != 0) m_ToolArcLineApprox.AddCurve( * pCurve, true) ; } @@ -1256,12 +1369,12 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d& bool VolZmap::DrillingZ( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir) { - + // Cilindro sfera toro if ( m_nToolType == CylindricalMill || m_nToolType == BallEndMill || m_nToolType == BullNoseMill) return CBTDrillZ( ptLs, ptLe, vtToolDir) ; - + // Coni else if ( m_nToolType == ConusMill) return ConusDrillingZ( ptLs, ptLe, vtToolDir) ; @@ -1360,11 +1473,10 @@ VolZmap::ConusDrillingZ( const Point3d ptLs, const Point3d ptLe, const Vector3d if ( m_dRadius < m_dTipRadius) - + // Coda di rondine return GetMinMaxZSw( ptO, nStartI, nEndI, nStartJ, nEndJ, dMinZ, dMaxZ, dMinRad, dMaxRad, vtToolDir.z, dDeltaZ) ; - + // Punta di trapano else - return GetMinMaxZDr( ptO, nStartI, nEndI, nStartJ, nEndJ, dMinZ, dMaxZ, dMinRad, dMaxRad, vtToolDir.z, dDeltaZ) ; } @@ -1378,6 +1490,8 @@ VolZmap::GetMinMaxZSw( const Point3d ptO, unsigned int nStartI, unsigned int nEn for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { + // Determinazione della posizione xy del dexel rispetto + // all'asse di simmetria dell'utensile double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1386,21 +1500,24 @@ VolZmap::GetMinMaxZSw( const Point3d ptO, unsigned int nStartI, unsigned int nEn double dSqDist = vtC * vtC ; - double dMin, dMax ; + // Se il dexel cade nel cerchio di interesse taglio if ( dSqDist < dMaxRad * dMaxRad) { + double dMin, dMax ; + if ( dSqDist < dMinRad * dMinRad) { dMin = dMinZ ; dMax = dMaxZ ; } else { + double dR = sqrt( dSqDist) ; if ( dDir > 0) { dMin = dMinZ ; - dMax = dMinZ + dDeltaZ + ( m_dTipHeight * ( dMaxRad - sqrt( dSqDist))) / ( dMaxRad - dMinRad) ; + dMax = dMinZ + dDeltaZ + ( m_dTipHeight * ( dMaxRad - dR)) / ( dMaxRad - dMinRad) ; } else { - dMin = dMaxZ - dDeltaZ + ( m_dTipHeight * ( sqrt( dSqDist) - dMaxRad)) / ( dMaxRad - dMinRad) ; + dMin = dMaxZ - dDeltaZ + ( m_dTipHeight * ( dR - dMaxRad)) / ( dMaxRad - dMinRad) ; dMax = dMaxZ ; } } @@ -1431,22 +1548,25 @@ VolZmap::GetMinMaxZDr( const Point3d ptO, unsigned int nStartI, unsigned int nEn double dSqDist = vtC * vtC ; - double dMin, dMax ; + // Se il dexel cade nel cerchio di interesse taglio if ( dSqDist < dMaxRad * dMaxRad) { + double dMin, dMax ; + if ( dSqDist < dMinRad * dMinRad) { dMin = dMinZ ; dMax = dMaxZ ; } else { + double dR = sqrt( dSqDist) ; if ( dDir > 0) { - dMin = dMinZ + ( m_dTipHeight * ( sqrt( dSqDist) - dMinRad)) / ( dMaxRad - dMinRad) ; + dMin = dMinZ + ( m_dTipHeight * ( dR - dMinRad)) / ( dMaxRad - dMinRad) ; dMax = dMaxZ ; } else { dMin = dMinZ ; - dMax = dMaxZ + ( m_dTipHeight * ( sqrt( dSqDist) - dMinRad)) / ( dMinRad - dMaxRad) ; + dMax = dMaxZ + ( m_dTipHeight * ( dR - dMinRad)) / ( dMinRad - dMaxRad) ; } } @@ -1461,19 +1581,19 @@ VolZmap::GetMinMaxZDr( const Point3d ptO, unsigned int nStartI, unsigned int nEn //---------------------------------------------------------------------------- bool VolZmap::MillingPerpZ( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir) { - + // Cilindro sfera toro if ( m_nToolType == CylindricalMill || m_nToolType == BallEndMill || m_nToolType == BullNoseMill) return CBTMillingPerpZ( ptLs, ptLe, vtToolDir) ; - + // Coni else if ( m_nToolType == ConusMill) return ConusPerpZ( ptLs, ptLe, vtToolDir) ; else - return true ; // forse qui ci va il nuovo + return false ; } //---------------------------------------------------------------------------- @@ -1601,14 +1721,16 @@ VolZmap::ConusPerpZ( const Point3d ptLs, const Point3d ptLe, const Vector3d vtTo else if ( dSqDist >= dMinRad * dMinRad && dSqDist < dMaxRad * dMaxRad) { - if ( m_dRadius < m_dTipRadius) { - dMin = min( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; - dMax = max( dZTip, dZStem+ ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; - } + double dr = sqrt( dSqDist) ; + if ( m_dRadius < m_dTipRadius) { + + dMin = min( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; + dMax = max( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; + } else { - dMin = min( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; - dMax = max( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; + dMin = min( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; + dMax = max( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; } SubtractIntervals( i, j, dMin, dMax) ; } @@ -1628,14 +1750,16 @@ VolZmap::ConusPerpZ( const Point3d ptLs, const Point3d ptLe, const Vector3d vtTo else if ( dSqDist >= dMinRad * dMinRad && dSqDist < dMaxRad * dMaxRad) { + double dr = sqrt( dSqDist) ; + if ( m_dRadius < m_dTipRadius) { - dMin = min( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; - dMax = max( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; + dMin = min( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; + dMax = max( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; } else { - dMin = min( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; - dMax = max( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; + dMin = min( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; + dMax = max( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; } SubtractIntervals( i, j, dMin, dMax) ; } @@ -1656,14 +1780,16 @@ VolZmap::ConusPerpZ( const Point3d ptLs, const Point3d ptLe, const Vector3d vtTo else if ( dSqDist >= dMinRad * dMinRad && dSqDist < dMaxRad * dMaxRad) { + double dr = sqrt( dSqDist) ; + if ( m_dRadius < m_dTipRadius) { - dMin = min( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; - dMax = max( dZTip, dZStem + ( sqrt( dSqDist) - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; + dMin = min( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; + dMax = max( dZTip, dZStem + ( dr - dMinRad) * ( dZTip - dZStem) / ( dMaxRad - dMinRad)) ; } else { - dMin = min( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; - dMax = max( dZBase, dZTip + ( sqrt( dSqDist) - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; + dMin = min( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; + dMax = max( dZBase, dZTip + ( dr - dMinRad) * ( dZStem - dZTip) / ( dMaxRad - dMinRad)) ; } SubtractIntervals( i, j, dMin, dMax) ; } @@ -1710,15 +1836,17 @@ VolZmap::GetMinMaxZ( unsigned int nI, unsigned int nJ, double dZCutBase, else if ( m_nToolType == 2) { double dMin, dMax ; + double dH = sqrt( dSqRad - dSqDist) ; + if ( abs( vtToolDir.z * dDeltaZ) < EPS_SMALL) { - dMin = min( dZCutBase, dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist))) ; - dMax = max( dZCutBase, dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist))) ; + dMin = min( dZCutBase, dZtip + dFactor*( m_dRadius - dH)) ; + dMax = max( dZCutBase, dZtip + dFactor*( m_dRadius - dH)) ; } else if ( vtToolDir.z * dDeltaZ < 0) { - dMin = min( dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)), - dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)) + dDeltaZ) ;// ocio - dMax = max( dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)), - dZtip + dFactor*( m_dRadius - sqrt( dSqRad - dSqDist)) + dDeltaZ) ;// ocio + dMin = min( dZtip + dFactor*( m_dRadius - dH), + dZtip + dFactor*( m_dRadius - dH) + dDeltaZ) ;// ocio + dMax = max( dZtip + dFactor*( m_dRadius - dH), + dZtip + dFactor*( m_dRadius - dH) + dDeltaZ) ;// ocio } else { dMin = min( dZCutBase, dZCutBase + dDeltaZ) ; @@ -1755,17 +1883,18 @@ VolZmap::GetMinMaxZ( unsigned int nI, unsigned int nJ, double dZCutBase, double dSqRadC = m_dRCorner * m_dRCorner ; double dSqd = dSqDist + dDeltaR * dDeltaR - 2 * sqrt( dSqDist) * dDeltaR ; + double dSqrt = sqrt(dSqRadC - dSqd) ; double dMin, dMax ; if ( abs( vtToolDir.z * dDeltaZ) < EPS_SMALL) { - dMin = min( dZCutBase, dZtip + dFactor*( m_dRCorner - sqrt(dSqRadC - dSqd))) ; - dMax = max( dZCutBase, dZtip + dFactor*( m_dRCorner - sqrt(dSqRadC - dSqd))) ; + dMin = min( dZCutBase, dZtip + dFactor*( m_dRCorner - dSqrt)) ; + dMax = max( dZCutBase, dZtip + dFactor*( m_dRCorner - dSqrt)) ; } else if ( vtToolDir.z * dDeltaZ < 0) { - dMin = min( dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)), - dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)) + dDeltaZ) ; - dMax = max( dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)), - dZtip + dFactor *( m_dRCorner - sqrt( dSqRadC - dSqd)) + dDeltaZ) ; + dMin = min( dZtip + dFactor *( m_dRCorner - dSqrt), + dZtip + dFactor *( m_dRCorner - dSqrt) + dDeltaZ) ; + dMax = max( dZtip + dFactor *( m_dRCorner - dSqrt), + dZtip + dFactor *( m_dRCorner - dSqrt) + dDeltaZ) ; } else { dMin = min( dZCutBase, dZCutBase + dDeltaZ) ; @@ -1934,15 +2063,20 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d // Apertura del cono e parametri per determinare i piani double dTanAlpha = ( dMaxRad - dMinRad) / m_dTipHeight ; double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ; + double dCos = dTanAlpha * dRatio ; + double dSin = ( abs( dCos) < 1 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTanAlpha * dTanAlpha) ; // Versori normali e prodotti scalari per per determinare i piani - Vector3d vtNs = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + - ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 + - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ; - Vector3d vtNd = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + - ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 - - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ; + Vector3d vtNs = - ( dTanAlpha / dDen) * vtV1 + + ( dCos / dDen) * vtV2 + + ( dSin / dDen) * vtV3 ; + Vector3d vtNd = - ( dTanAlpha / dDen) * vtV1 + + ( dCos / dDen) * vtV2 - + ( dSin / dDen) * vtV3 ; + Vector3d vtR0 = ptV - ORIG ; double dDots = vtR0 * vtNs ; double dDotd = vtR0 * vtNd ; @@ -1956,7 +2090,7 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) { for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) { - + // Grandezze per determinare la configurazione geometrica dell'utensile double dMin, dMax ; double dX = ( i + 0.5) * m_dStep ; double dY = ( j + 0.5) * m_dStep ; @@ -1978,10 +2112,13 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d double dSqDistM = vtOrt * vtOrt ; double dSqDistF = vtCf * vtCf ; + // Se dentro la zona interessata dalla lavorazione valuto + // la tipologia di tale zona if ( ( dProj < 0 && dSqDistI < dMaxRad * dMaxRad) || ( dProj >= 0 && dProj < dLen && dSqDistM < dMaxRad * dMaxRad) || ( dProj >= dLen && dSqDistF < dMaxRad * dMaxRad)) { + // Caso vettore utensile equiverso all'asse Z if ( vtToolDir.z > 0) { // Massimi double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ; @@ -2050,7 +2187,7 @@ VolZmap::ConusMillingZDr( const Point3d ptLs, const Point3d ptLe, const Vector3d } } } - + // Caso vettore utensile opposto all'asse Z else { // Massimi double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ; @@ -2198,15 +2335,20 @@ VolZmap::ConusMillingZSw( const Point3d ptLs, const Point3d ptLe, const Vector3d // Apertura del cono e parametri per determinare i piani double dTanAlpha = ( dMaxRad - dMinRad) / m_dTipHeight ; double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ; + double dCos = dTanAlpha * dRatio ; - + double dSin = ( abs( dCos) < 1 ? sqrt( 1- dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTanAlpha * dTanAlpha) ; + // Versori normali e prodotti scalari per per determinare i piani - Vector3d vtNp = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + - ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 + - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ; - Vector3d vtNm = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + - ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 - - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ; + Vector3d vtNp = - ( dTanAlpha / dDen) * vtV1 + + ( dCos / dDen) * vtV2 + + ( dSin / dDen) * vtV3 ; + Vector3d vtNm = - ( dTanAlpha / dDen) * vtV1 + + ( dCos / dDen) * vtV2 - + ( dSin / dDen) * vtV3 ; + Vector3d vtR0 = ptV - ORIG ; double dDotp = vtR0 * vtNp ; double dDotm = vtR0 * vtNm ; @@ -2240,7 +2382,7 @@ VolZmap::ConusMillingZSw( const Point3d ptLs, const Point3d ptLe, const Vector3d if ( ( dProj < 0 && dSqDistI < dMaxRad * dMaxRad) || ( dProj >= 0 && dProj < dLen && dSqDistM < dMaxRad * dMaxRad) || ( dProj >= dLen && dSqDistF < dMaxRad * dMaxRad)) { - + // Caso vettore utensile equiverso all'asse Z if ( vtV1.z < 0) { double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ; @@ -2318,7 +2460,8 @@ VolZmap::ConusMillingZSw( const Point3d ptLs, const Point3d ptLe, const Vector3d dMin = dZIS - m_dTipHeight + ( dProj + dPMaxI) * dDeltaZ / dLen ; - } // Fine vtV1 < 0 + } + // Caso vettore utensile opposto all'asse Z else { double dPMaxI = ( dMaxRad * dMaxRad - dSqDistM > 0 ? sqrt( dMaxRad * dMaxRad - dSqDistM) : 0) ; @@ -3582,16 +3725,22 @@ VolZmap::ConusPlaneGen( const Point3d& ptLs, const Point3d& ptLe, const Vector3d Vector3d vtV3 = vtV1 ^ vtV2 ; double dTan = ( dMaxRad - dMinRad) / m_dTipHeight ; - double dCos = dTan * ( vtMove * vtV1) / ( vtMove * vtV2) ; double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ; + double dCos = dTan * dRatio ; + double dSin = ( abs( dCos) < 1 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTan * dTan) ; + double dDeltaR = dMaxRad - dMinRad ; double dMinLim = dMinRad * dCos ; double dMaxLim = dMaxRad * dCos ; - // Versori normali e prodotti scalari per per determinare i piani - Vector3d vtNInf = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ; - Vector3d vtNSup = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ; + + // Versori normali e prodotti scalari per determinare i piani + Vector3d vtNInf = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ; + Vector3d vtNSup = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ; + Point3d ptV = ptI - vtV1 * ( dMaxRad * m_dTipHeight) / ( dMaxRad - dMinRad) ; Vector3d vtR0 = ptV - ORIG ; double dDotInf = vtR0 * vtNInf ; @@ -4260,12 +4409,15 @@ VolZmap::XYLongVertConus( const Point3d& ptLs, const Point3d& ptLe, const Vector // Apertura del cono e parametri per determinare i piani double dTan = ( dMaxRad - dMinRad) / m_dTipHeight ; double dRatio = ( dDeltaZ > 0 ? - ( vtMove * vtV1) / ( vtMove * vtV3) : ( vtMove * vtV1) / ( vtMove * vtV3)) ; + double dCos = dTan * dRatio ; - double dSen = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTan * dTan) ; // Versori normali e prodotti scalari per per determinare i piani - Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + dFactor * ( dCos / sqrt( 1 + dTan * dTan)) * vtV3 - dFactor * ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV2 ; - Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + dFactor * ( dCos / sqrt( 1 + dTan * dTan)) * vtV3 + dFactor * ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV2 ; + Vector3d vtNs = - ( dTan / dDen) * vtV1 + dFactor * ( dCos / dDen) * vtV3 - dFactor * ( dSin / dDen) * vtV2 ; + Vector3d vtNd = - ( dTan /dDen) * vtV1 + dFactor * ( dCos / dDen) * vtV3 + dFactor * ( dSin / dDen) * vtV2 ; Vector3d vtR0 = ptV - ORIG ; double dDots = vtR0 * vtNs ; double dDotd = vtR0 * vtNd ; @@ -4289,7 +4441,7 @@ VolZmap::XYLongVertConus( const Point3d& ptLs, const Point3d& ptLe, const Vector if ( dRatio <= 1 / dTan) { - if ( dProj1 < m_dTipHeight && dOrtLen < dMaxRad * dSen - dProj1 * dDeltaR * dSen / m_dTipHeight) { // Il limite inferiore d dProj1 è già stato imposto dall' if più esterno + if ( dProj1 < m_dTipHeight && dOrtLen < dMaxRad * dSin - dProj1 * dDeltaR * dSin / m_dTipHeight) { // Il limite inferiore d dProj1 è già stato imposto dall' if più esterno double dr = dMaxRad - dProj1 * dDeltaR / m_dTipHeight ; double dH = sqrt( dr * dr - dOrtLen * dOrtLen) ; @@ -4297,21 +4449,21 @@ VolZmap::XYLongVertConus( const Point3d& ptLs, const Point3d& ptLe, const Vector dZL1 = dZI + dFactor * dH ; } else if ( dProj1 > 0 && dProj1 < dPLen && - dOrtLen > dMaxRad * dSen && dOrtLen < dMaxRad) { + dOrtLen > dMaxRad * dSin && dOrtLen < dMaxRad) { double dH = sqrt( dMaxRad * dMaxRad - dOrtLen * dOrtLen) ; dZL1 = dZI + dFactor * dH + dProj1 * dDeltaZ / dPLen ; } else if ( dProj1 > m_dTipHeight && dProj1 < dPLen + m_dHeight && - dOrtLen < dMinRad * dSen) { + dOrtLen < dMinRad * dSin) { double dH = sqrt( dMinRad * dMinRad - dOrtLen * dOrtLen) ; dZL1 = dZI + dFactor * dH + ( dProj1 - m_dTipHeight) * dDeltaZ / dPLen ; } else if ( dProj1 >= dPLen && - dOrtLen > dMaxRad * dSen - ( dProj1 - dPLen) * dDeltaR * dSen / m_dTipHeight) { // I limiti superiori sono già stati imposti dall' if più esterno + dOrtLen > dMaxRad * dSin - ( dProj1 - dPLen) * dDeltaR * dSin / m_dTipHeight) { // I limiti superiori sono già stati imposti dall' if più esterno double dr = dMaxRad - ( dProj1 - dPLen) * dDeltaR / m_dTipHeight ; @@ -4810,11 +4962,16 @@ VolZmap::MillingXYConus( const Point3d& ptLs, const Point3d& ptLe, const Vector3 // Apertura del cono e parametri per determinare i piani double dTanAlpha = ( dMaxRad - dMinRad) / m_dTipHeight ; double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ; + double dCos = dTanAlpha * dRatio ; + double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTanAlpha * dTanAlpha) ; // Versori normali e prodotti scalari per per determinare i piani - Vector3d vtNs = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 + ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ; - Vector3d vtNd = - ( dTanAlpha / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV1 + ( dCos / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV2 - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTanAlpha * dTanAlpha)) * vtV3 ; + Vector3d vtNs = - ( dTanAlpha / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ; + Vector3d vtNd = - ( dTanAlpha / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ; + Vector3d vtR0 = ptV - ORIG ; double dDots = vtR0 * vtNs ; double dDotd = vtR0 * vtNd ; @@ -5392,7 +5549,11 @@ VolZmap::MillingXYPlusConus( const Point3d& ptLs, const Point3d& ptLe, const Vec // Apertura del cono e parametri per determinare i piani double dTan = ( dMaxRad - dMinRad) / m_dTipHeight ; double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ; + double dCos = dTan * dRatio ; // dCos è compreso fra 0 e 1 poiché alpha è compreso fra 0 e Pi mezzi + double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTan * dTan) ; double dZI = ptI.z ; double dDeltaZ = ptF.z - ptI.z ; @@ -5410,9 +5571,11 @@ VolZmap::MillingXYPlusConus( const Point3d& ptLs, const Point3d& ptLe, const Vec Point3d ptrSup = ( ptPrs.z < ptPrd.z ? ptPrd : ptPrs) ; // Versori normali e prodotti scalari per per determinare i piani - Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ; - Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( sqrt( 1 - dCos * dCos) / sqrt( 1 + dTan * dTan)) * vtV3 ; + Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ; + Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ; + Vector3d vtR0 = ptV - ORIG ; + double dDots = vtR0 * vtNs ; double dDotd = vtR0 * vtNd ; @@ -6048,31 +6211,31 @@ VolZmap::MillCylV( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT double dX1 = vtC * vtV1 ; double dX2 = vtC * vtV2 ; + double dLimX1 = sqrt( dRad * dRad - dX2 * dX2) ; + if ( dX2 > - dRad && dX2 < dRad && - dX1 > - sqrt( dRad * dRad - dX2 * dX2) && - dX1 < dPLen + sqrt( dRad * dRad - dX2 * dX2)) { + dX1 > - dLimX1 && + dX1 < dPLen + dLimX1) { // Massimi - if( dX1 > - sqrt( dRad * dRad - dX2 * dX2) && - dX1 < dPLen - sqrt( dRad * dRad - dX2 * dX2)) + if( dX1 > - dLimX1 && dX1 < dPLen - dLimX1) - dMax = dZI + ( dX1 + sqrt( dRad * dRad - dX2 * dX2)) * dDeltaZ / dPLen ; + dMax = dZI + ( dX1 + dLimX1) * dDeltaZ / dPLen ; - else if ( dX1 >= dPLen - sqrt( dRad * dRad - dX2 * dX2) && - dX1 < dPLen + sqrt( dRad * dRad - dX2 * dX2)) + else if ( dX1 >= dPLen - dLimX1 && + dX1 < dPLen + dLimX1) dMax = dZI + dDeltaZ ; // Minimi - if ( dX1 > - sqrt( dRad * dRad - dX2 * dX2) && - dX1 < sqrt( dRad * dRad - dX2 * dX2)) + if ( dX1 > - dLimX1 && dX1 < dLimX1) dMin = dZI - dHei ; - else if ( dX1 >= sqrt( dRad * dRad - dX2 * dX2) && - dX1 < dPLen + sqrt( dRad * dRad - dX2 * dX2)) + else if ( dX1 >= dLimX1 && + dX1 < dPLen + dLimX1) - dMin = dZI - dHei + ( dX1 - sqrt( dRad * dRad - dX2 * dX2)) * dDeltaZ / dPLen ; + dMin = dZI - dHei + ( dX1 - dLimX1) * dDeltaZ / dPLen ; SubtractIntervals( i, j, dMin, dMax) ; } @@ -6116,13 +6279,16 @@ VolZmap::MillConusV( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& v double dTan = dDeltaR / dHei ; double dRatio = ( vtMove * vtV1) / ( vtMove * vtV2) ; + double dCos = dTan * dRatio ; double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTan * dTan) ; Point3d ptV = ptI - vtV1 * ( dHei * dMaxRad / dDeltaR) ; - Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ; - Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ; + Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ; + Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ; Vector3d vtR0 = ptV - ORIG ; double dDots = vtR0 * vtNs ; @@ -6447,7 +6613,9 @@ VolZmap::LongCyl( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtTo if ( vtU1.LenXY() < EPS_SMALL) { - vtU1 = ( 1 + sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y)) / sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y) * vtU1 ; + double dLenVector = sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y) ; + + vtU1 = ( 1 + dLenVector) / dLenVector * vtU1 ; } vtU1.Normalize() ; @@ -6536,8 +6704,13 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT // Definizione del sistema di riferimento nel piano Vector3d vtU1 = vtMoveOri ; - if ( vtU1.LenXY() < EPS_SMALL) - vtU1 = ( 1 + sqrt(vtMove.x * vtMove.x + vtMove.y * vtMove.y)) / sqrt(vtMove.x * vtMove.x + vtMove.y * vtMove.y) * vtU1 ; + if ( vtU1.LenXY() < EPS_SMALL) { + + double dLenVector = sqrt(vtMove.x * vtMove.x + vtMove.y * vtMove.y) ; + + vtU1 = ( 1 + dLenVector) / dLenVector * vtU1 ; + } + vtU1.Normalize() ; @@ -6566,18 +6739,20 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT double dPI1 = vtCI * vtU1 ; double dPI2 = vtCI * vtU2 ; double dPF1 = vtCF * vtU1 ; double dPF2 = vtCF * vtU2 ; - // Massimi - if ( ( dPI1 > - dCos * sqrt( dRad * dRad - dPI2 * dPI2) && + double dLimP1 = sqrt( dRad * dRad - dPI2 * dPI2) ; + + // Dexel nella regione interessata dalla lavorazione + if ( ( dPI1 > - dCos * dLimP1 && dPI1 < dLOri && dPI2 * dPI2 < dRad * dRad) || ( dPF1 * dPF1 + dPF2 * dPF2 < dRad * dRad)) { if ( dDeltaZ > 0) { // Massimi - if ( dPI1 < dLOri - dCos * sqrt( dRad * dRad - dPI2 * dPI2)) { + if ( dPI1 < dLOri - dCos * dLimP1) { - double dPI0 = - dCos * sqrt( dRad * dRad - dPI2 * dPI2) ; - double dZ0 = dSin * sqrt( dRad * dRad - dPI2 * dPI2) ; + double dPI0 = - dCos * dLimP1 ; + double dZ0 = dSin * dLimP1 ; dMax = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ; } @@ -6590,14 +6765,14 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT } // Minimi - if ( dPI1 < dCos * sqrt( dRad * dRad - dPI2 * dPI2)) + if ( dPI1 < dCos * dLimP1) dMin = ( dDotI - dX * vtV.x - dY * vtV.y) / vtV.z ; - else if ( dPI1 < dLOri + dCos * sqrt( dRad * dRad - dPI2 * dPI2)) { + else if ( dPI1 < dLOri + dCos * dLimP1) { - double dPI0 = dCos * sqrt( dRad * dRad - dPI2 * dPI2) ; - double dZ0 = - dSin * sqrt( dRad * dRad - dPI2 * dPI2) ; + double dPI0 = dCos * dLimP1 ; + double dZ0 = - dSin * dLimP1 ; dMin = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ; } @@ -6612,14 +6787,14 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT else { // Massimi - if ( dPI1 < dCos * sqrt( dRad * dRad - dPI2 * dPI2)) + if ( dPI1 < dCos * dLimP1) dMax = ( dDotI - dX * vtV.x - dY * vtV.y) / vtV.z ; - else if ( dPI1 < dLOri + dCos * sqrt( dRad * dRad - dPI2 * dPI2)) { + else if ( dPI1 < dLOri + dCos * dLimP1) { - double dPI0 = dCos * sqrt( dRad * dRad - dPI2 * dPI2) ; - double dZ0 = + dSin * sqrt( dRad * dRad - dPI2 * dPI2) ; + double dPI0 = dCos * dLimP1 ; + double dZ0 = + dSin * dLimP1 ; dMax = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ; } @@ -6632,10 +6807,10 @@ VolZmap::LongBall( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtT } // Minimi - if ( dPI1 < dLOri - dCos * sqrt( dRad * dRad - dPI2 * dPI2)) { + if ( dPI1 < dLOri - dCos * dLimP1) { - double dPI0 = - dCos * sqrt( dRad * dRad - dPI2 * dPI2) ; - double dZ0 = - dSin * sqrt( dRad * dRad - dPI2 * dPI2) ; + double dPI0 = - dCos * dLimP1 ; + double dZ0 = - dSin * dLimP1 ; dMin = dZI + dZ0 + ( dPI1 - dPI0) * dDeltaZ / dLOri ; } @@ -8181,8 +8356,11 @@ VolZmap::MillConus( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vt // Apertura del cono e parametri per determinare i piani double dTan = dDeltaR / dHei ; double dRatio = dLLong / dLOrt ; + double dCos = dTan * dRatio ; double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ; + + double dDen = sqrt( 1 + dTan * dTan) ; double dCoef = dLOrt / dLLong ; // Per traslazione ellissi if ( dRatio > 1 / dTan) @@ -8192,8 +8370,8 @@ VolZmap::MillConus( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vt // Versori normali e prodotti scalari per per determinare i piani // Piani laterali: - Vector3d vtNs = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 + ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ; - Vector3d vtNd = - ( dTan / sqrt( 1 + dTan * dTan)) * vtV1 + ( dCos / sqrt( 1 + dTan * dTan)) * vtV2 - ( dSin / sqrt( 1 + dTan * dTan)) * vtV3 ; + Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ; + Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ; Vector3d vtRIV = ptIV - ORIG ; // double dDots = vtRIV * vtNs ; // forse qui è meglio due punti ptIT + vtV3 * dMinRad e ptIT - vtV3 * dMinRad // double dDotd = vtRIV * vtNd ; @@ -9045,8 +9223,10 @@ VolZmap::Ball( const Point3d& ptLs, const Point3d& ptLe, double dRad) if ( dSqLen < dRad * dRad) { - dMin = dZI - sqrt( dRad * dRad - dSqLen) ; - dMax = dZI + dDeltaZ + sqrt( dRad * dRad - dSqLen) ; + double dH = sqrt( dRad * dRad - dSqLen) ; + + dMin = dZI - dH ; + dMax = dZI + dDeltaZ + dH ; SubtractIntervals( i, j, dMin, dMax) ; } diff --git a/VolZmap.h b/VolZmap.h index 8f5c720..a69838c 100644 --- a/VolZmap.h +++ b/VolZmap.h @@ -61,7 +61,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW public : // IVolZmap bool CopyFrom( const IGeoObj* pGObjSrc) override ; - bool CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double dLengthZ, double dPrec) ; + bool CreateMap( const Point3d& ptO, double dDimX, double dDimY, double dDimZ, double dPrec) ; + bool CreateMapFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec) ; bool GetAllTriangles( TRIA3DLIST& lstTria) const override ; bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const override ; bool SetTolerances( double dLinTol, double dAngTolDeg = 90) override ;