diff --git a/Tool.cpp b/Tool.cpp index b66b713..10faa3e 100644 --- a/Tool.cpp +++ b/Tool.cpp @@ -680,7 +680,6 @@ Tool::SetAdditiveTool( const std::string& sToolName, double dH, double dR, doubl if ( dH < EPS_SMALL || dR < EPS_SMALL || dRC < - EPS_SMALL) return false ; - /*m_nType = ADDITIVE ;*/ m_dHeight = dH ; m_dRadius = dR ; m_dRCorner = dRC ; diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp index 8f1952a..0e36d60 100644 --- a/VolZmapVolume.cpp +++ b/VolZmapVolume.cpp @@ -7969,6 +7969,390 @@ VolZmap::AddingCylinder( int nGrid, const Point3d& ptS, const Point3d& ptE, cons } //---------------------------------------------------------------------------- +//bool +//VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, +// double dMaxRad, double dMinRad, double dHei, +// const Vector3d& vtArcNormMaxR, const Vector3d& vtArcNormMinR) +//{ +// // Verifico interferenza +// int nStartI, nStartJ, nEndI, nEndJ ; +// if ( ! TestCompoBBox( nGrid, ptS, ptE, vtAx, dMaxRad, dMinRad, dHei, nStartI, nStartJ, nEndI, nEndJ)) +// return true ; +// +// // Geometria del cono +// double dDeltaR = dMaxRad - dMinRad ; +// +// // Studio simmetrie +// Point3d ptI = ( vtAx * ( ptE - ptS) > 0 ? ptS : ptE) ; +// Point3d ptF = ( vtAx * ( ptE - ptS) > 0 ? ptE : ptS) ; +// +// double dL = ( dMaxRad * dHei) / dDeltaR ; +// double dl = dL - dHei ; +// +// Point3d ptV = ptI - vtAx * dL ; +// +// // Vettori caratteristici del movimento +// Vector3d vtMove = ptF - ptI ; +// Vector3d vtMvLong = ( vtMove * vtAx) * vtAx ; +// Vector3d vtMvOrt = vtMove - vtMvLong ; +// +// // Terna destrorsa e unitaria +// Vector3d vtV1 = vtAx ; +// 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)) { +// vtN1 *= - 1 ; +// vtN2 *= - 1 ; +// if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { +// if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { +// Vector3d vtL1 = ptInt1 - ptV ; +// vtL1 -= ( vtL1 * vtAx) * vtAx ; +// double dL1 = vtL1.Len() ; +// vtL1 /= dL1 ; +// Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR; +// vtOriginalN1.Normalize() ; +// vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; +// vtN1.Normalize() ; +// } +// if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) { +// Vector3d vtL2 = ptInt2 - ptV ; +// vtL2 -= ( vtL2 * vtAx) * vtAx ; +// double dL2 = vtL2.Len() ; +// vtL2 /= dL2 ; +// Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; +// vtOriginalN2.Normalize() ; +// vtN2 = vtOriginalN2.z * vtAx + 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)) { +// vtN1 *= - 1 ; +// vtN2 *= - 1 ; +// if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { +// if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { +// Vector3d vtL1 = ptInt1 - ptV - vtMove ; +// vtL1 -= ( vtL1 * vtAx) * vtAx ; +// double dL1 = vtL1.Len() ; +// vtL1 /= dL1 ; +// Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; +// vtOriginalN1.Normalize() ; +// vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; +// vtN1.Normalize() ; +// } +// if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtAx, 0.1 * EPS_SMALL)) { +// Vector3d vtL2 = ptInt2 - ptV - vtMove ; +// vtL2 -= (vtL2 * vtAx) * vtAx; +// double dL2 = vtL2.Len() ; +// vtL2 /= dL2 ; +// Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; +// vtOriginalN2.Normalize() ; +// vtN2 = vtOriginalN2.z * vtAx + 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 + EPS_SMALL) > dLenX * ptPoly1.y && +// dLenY * ( ptPoly1.x - dDeltaX - EPS_SMALL) < dLenX * ( ptPoly1.y - dDeltaY) && +// dDeltaX * ( ptPoly1.y + EPS_SMALL) > dDeltaY * ptPoly1.x && +// dDeltaX * ( ptPoly1.y - dLenY - EPS_SMALL) < 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 + EPS_SMALL) > dLenX * ptPoly2.y && +// dLenY * ( ptPoly2.x - dDeltaX - EPS_SMALL) < dLenX * ( ptPoly2.y - dDeltaY) && +// dDeltaX * ( ptPoly2.y + EPS_SMALL) > dDeltaY * ptPoly2.x && +// dDeltaX * ( ptPoly2.y - dLenY - EPS_SMALL) < 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 > - EPS_SMALL && ptPoly3.x < dDeltaX + EPS_SMALL && +// dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x + dDeltaX * EPS_SMALL) { +// +// 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 - EPS_SMALL && ptPoly4.x < dLenX + dDeltaX + EPS_SMALL && +// dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX) + dDeltaX * EPS_SMALL) { +// +// 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)) { +// vtN1 *= - 1 ; +// vtN2 *= - 1 ; +// if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { +// if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { +// Vector3d vtL1 = ptInt1 - ptV ; +// vtL1 -= ( vtL1 * vtAx) * vtAx ; +// double dL1 = vtL1.Len() ; +// vtL1 /= dL1 ; +// Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; +// vtOriginalN1.Normalize() ; +// vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; +// vtN1.Normalize() ; +// } +// if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) { +// Vector3d vtL2 = ptInt2 - ptV ; +// vtL2 -= ( vtL2 * vtAx) * vtAx ; +// double dL2 = vtL2.Len() ; +// vtL2 /= dL2 ; +// Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; +// vtOriginalN2.Normalize() ; +// vtN2 = vtOriginalN2.z * vtAx + 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 ; +// } +//} bool VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtAx, double dMaxRad, double dMinRad, double dHei, @@ -7992,6 +8376,7 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, Point3d ptV = ptI - vtAx * dL ; // Vettori caratteristici del movimento + // Elimino eventuali componenti del moto lungo l'asse. Vector3d vtMove = ptF - ptI ; Vector3d vtMvLong = ( vtMove * vtAx) * vtAx ; Vector3d vtMvOrt = vtMove - vtMvLong ; @@ -8005,7 +8390,7 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, Frame3d ConusFrame ; ConusFrame.Set( ptV, vtV2, vtV3, vtV1) ; // Dimensioni lineari movimento - double dLongLen = vtMvLong.Len() ; + double dLongLen = 0/*vtMvLong.Len()*/ ; double dOrtLen = vtMvOrt.Len() ; // Apertura del cono @@ -8048,310 +8433,239 @@ VolZmap::AddingTruncatedCone( int nGrid, const Point3d& ptS, const Point3d& ptE, 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)) { - vtN1 *= - 1 ; - vtN2 *= - 1 ; - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { - Vector3d vtL1 = ptInt1 - ptV ; - vtL1 -= ( vtL1 * vtAx) * vtAx ; - double dL1 = vtL1.Len() ; - vtL1 /= dL1 ; - Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR; - vtOriginalN1.Normalize() ; - vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; - vtN1.Normalize() ; - } - if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) { - Vector3d vtL2 = ptInt2 - ptV ; - vtL2 -= ( vtL2 * vtAx) * vtAx ; - double dL2 = vtL2.Len() ; - vtL2 /= dL2 ; - Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN2.Normalize() ; - vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ; - vtN2.Normalize() ; - } - } - AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; - } + for ( int i = nStartI ; i <= nEndI ; ++ i) { + for ( int j = nStartJ ; j <= nEndJ ; ++ j) { - // Cono finale - ConusFrame.ChangeOrig( ptV + vtMove) ; - if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, true, true, ptInt1, vtN1, ptInt2, vtN2)) { - vtN1 *= - 1 ; - vtN2 *= - 1 ; - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { - Vector3d vtL1 = ptInt1 - ptV - vtMove ; - vtL1 -= ( vtL1 * vtAx) * vtAx ; - double dL1 = vtL1.Len() ; - vtL1 /= dL1 ; - Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN1.Normalize() ; - vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; - vtN1.Normalize() ; - } - if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtAx, 0.1 * EPS_SMALL)) { - Vector3d vtL2 = ptInt2 - ptV - vtMove ; - vtL2 -= (vtL2 * vtAx) * vtAx; - double dL2 = vtL2.Len() ; - vtL2 /= dL2 ; - Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN2.Normalize() ; - vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ; - vtN2.Normalize() ; - } + 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)) { + vtN1 *= - 1 ; + vtN2 *= - 1 ; + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { + Vector3d vtL1 = ptInt1 - ptV ; + vtL1 -= ( vtL1 * vtAx) * vtAx ; + double dL1 = vtL1.Len() ; + vtL1 /= dL1 ; + Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ((dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR; + vtOriginalN1.Normalize() ; + vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; + vtN1.Normalize() ; + } + if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) { + Vector3d vtL2 = ptInt2 - ptV ; + vtL2 -= ( vtL2 * vtAx) * vtAx ; + double dL2 = vtL2.Len() ; + vtL2 /= dL2 ; + Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN2.Normalize() ; + vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ; + vtN2.Normalize() ; } - AddIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2) ; } - - // Solido interno - Point3d ptPoly = ptC ; - Vector3d vtPoly = Z_AX ; + 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)) { + vtN1 *= - 1 ; + vtN2 *= - 1 ; + if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { + if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { + Vector3d vtL1 = ptInt1 - ptV - vtMove ; + vtL1 -= ( vtL1 * vtAx) * vtAx ; + double dL1 = vtL1.Len() ; + vtL1 /= dL1 ; + Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN1.Normalize() ; + vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; + vtN1.Normalize() ; + } + if ( ! AreSameOrOppositeVectorEpsilon(vtN2, vtAx, 0.1 * EPS_SMALL)) { + Vector3d vtL2 = ptInt2 - ptV - vtMove ; + vtL2 -= (vtL2 * vtAx) * vtAx; + double dL2 = vtL2.Len() ; + vtL2 /= dL2 ; + Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; + vtOriginalN2.Normalize() ; + vtN2 = vtOriginalN2.z * vtAx + 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) ; + 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 ; + 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 ; + int nIntNum = 0 ; - // Intersezione con la prima faccia - if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) { - if ( dLenY * ( ptPoly1.x + EPS_SMALL) > dLenX * ptPoly1.y && - dLenY * ( ptPoly1.x - dDeltaX - EPS_SMALL) < dLenX * ( ptPoly1.y - dDeltaY) && - dDeltaX * ( ptPoly1.y + EPS_SMALL) > dDeltaY * ptPoly1.x && - dDeltaX * ( ptPoly1.y - dLenY - EPS_SMALL) < dDeltaY * ( ptPoly1.x - dLenX)) { - ptInt1 = ptPoly1 ; - vtN1 = - vtNs ; + // Intersezione con la prima faccia + if ( abs( vtPoly * vtNs) > COS_ORTO_ANG_ZERO) { + if ( dLenY * ( ptPoly1.x + EPS_SMALL) > dLenX * ptPoly1.y && + dLenY * ( ptPoly1.x - dDeltaX - EPS_SMALL) < dLenX * ( ptPoly1.y - dDeltaY) && + dDeltaX * ( ptPoly1.y + EPS_SMALL) > dDeltaY * ptPoly1.x && + dDeltaX * ( ptPoly1.y - dLenY - EPS_SMALL) < 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 + EPS_SMALL) > dLenX * ptPoly2.y && + dLenY * ( ptPoly2.x - dDeltaX - EPS_SMALL) < dLenX * ( ptPoly2.y - dDeltaY) && + dDeltaX * ( ptPoly2.y + EPS_SMALL) > dDeltaY * ptPoly2.x && + dDeltaX * ( ptPoly2.y - dLenY - EPS_SMALL) < dDeltaY * ( ptPoly2.x - dLenX)) { + + if ( nIntNum == 0) { + ptInt1 = ptPoly2 ; + vtN1 = - vtNd ; if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - Vector3d vtRadial( 0, dMinRad * dCos, dMinRad * dSin) ; + 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 = - ( ( 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 seconda faccia - if ( abs( vtPoly * vtNd) > COS_ORTO_ANG_ZERO) { - if ( dLenY * ( ptPoly2.x + EPS_SMALL) > dLenX * ptPoly2.y && - dLenY * ( ptPoly2.x - dDeltaX - EPS_SMALL) < dLenX * ( ptPoly2.y - dDeltaY) && - dDeltaX * ( ptPoly2.y + EPS_SMALL) > dDeltaY * ptPoly2.x && - dDeltaX * ( ptPoly2.y - dLenY - EPS_SMALL) < dDeltaY * ( ptPoly2.x - dLenX)) { + } + // Intersezione con la terza faccia + if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { + if ( nIntNum < 2 && + ptPoly3.x > - EPS_SMALL && ptPoly3.x < dDeltaX + EPS_SMALL && + dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x + dDeltaX * EPS_SMALL) { - 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 ; - } + if ( nIntNum == 0) { + ptInt1 = ptPoly3 ; + vtN1 = - vtIF ; + ++ nIntNum ; } - } - // Intersezione con la terza faccia - if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { - if ( nIntNum < 2 && - ptPoly3.x > - EPS_SMALL && ptPoly3.x < dDeltaX + EPS_SMALL && - dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x + dDeltaX * EPS_SMALL) { - - 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 - EPS_SMALL && ptPoly4.x < dLenX + dDeltaX + EPS_SMALL && - dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX) + dDeltaX * EPS_SMALL) { - - 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) ; + else if ( ( ptInt1 - ptPoly3).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly3 ; + vtN2 = - vtIF ; + ++ nIntNum ; } } } - } - return true ; - } - else { - for ( int i = nStartI ; i <= nEndI ; ++ i) { - for ( int j = nStartJ ; j <= nEndJ ; ++ j) { + // Intersezione con la quarta faccia + if ( abs( vtPoly * vtIF) > COS_ORTO_ANG_ZERO) { + if ( nIntNum < 2 && + ptPoly4.x > dLenX - EPS_SMALL && ptPoly4.x < dLenX + dDeltaX + EPS_SMALL && + dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX) + dDeltaX * EPS_SMALL) { - 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)) { - vtN1 *= - 1 ; - vtN2 *= - 1 ; - if ( ! ( vtArcNormMaxR.IsSmall() || vtArcNormMinR.IsSmall())) { - if ( ! AreSameOrOppositeVectorEpsilon( vtN1, vtAx, 0.1 * EPS_SMALL)) { - Vector3d vtL1 = ptInt1 - ptV ; - vtL1 -= ( vtL1 * vtAx) * vtAx ; - double dL1 = vtL1.Len() ; - vtL1 /= dL1 ; - Vector3d vtOriginalN1 = ( ( dDeltaR - dL1 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL1 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN1.Normalize() ; - vtN1 = vtOriginalN1.z * vtAx + vtOriginalN1.x * vtL1 ; - vtN1.Normalize() ; - } - if ( ! AreSameOrOppositeVectorEpsilon( vtN2, vtAx, 0.1 * EPS_SMALL)) { - Vector3d vtL2 = ptInt2 - ptV ; - vtL2 -= ( vtL2 * vtAx) * vtAx ; - double dL2 = vtL2.Len() ; - vtL2 /= dL2 ; - Vector3d vtOriginalN2 = ( ( dDeltaR - dL2 + dMinRad) / dDeltaR) * vtArcNormMinR + ( ( dL2 - dMinRad) / dDeltaR) * vtArcNormMaxR ; - vtOriginalN2.Normalize() ; - vtN2 = vtOriginalN2.z * vtAx + vtOriginalN2.x * vtL2 ; - vtN2.Normalize() ; - } + if ( nIntNum == 0) { + ptInt1 = ptPoly4 ; + vtN1 = vtIF ; + ++ nIntNum ; + } + else if ( ( ptInt1 - ptPoly4).SqLen() > SQ_EPS_SMALL) { + ptInt2 = ptPoly4 ; + vtN2 = vtIF ; + ++ nIntNum ; } - 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) ; } } + + // 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, aggiungo + 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) ; + } } - return true ; } + return true ; } //----------------------------------------------------------------------------