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

EgtGeomKernel 2.1e3 :

Browse Source 
- modifiche a Zmap per intersezioni con linee e piani.
This commit is contained in:
Dario Sassi
2019-05-13 06:36:58 +00:00
parent 4e8508f731
commit 90df6d3a7a
7 changed files with 758 additions and 768 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtGeomKernel.rc
BIN
View File
Binary file not shown.
EgtGeomKernel.vcxproj
+23 -4
View File
@@ -411,6 +411,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="..\Include\EGkCurveLocal.h" />
<ClInclude Include="..\Include\EGkCurvePointDiffGeom.h" />
<ClInclude Include="..\Include\EGkDistPointCurve.h" />
<ClInclude Include="..\Include\EGkDistPointSurfTm.h" />
<ClInclude Include="..\Include\EGkDistPointTria.h" />
<ClInclude Include="..\Include\EGkDllMain.h" />
<ClInclude Include="..\Include\EGkExtText.h" />
@@ -429,6 +430,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="..\Include\EGkGeoPoint3d.h" />
<ClInclude Include="..\Include\EGkGeoCollection.h" />
<ClInclude Include="..\Include\EGkGeoVector3d.h" />
<ClInclude Include="..\Include\EGkHashGrids2d.h" />
<ClInclude Include="..\Include\EGkHashGrids3d.h" />
<ClInclude Include="..\Include\EGkIntersCurves.h" />
<ClInclude Include="..\Include\EGkIntersLinePlane.h" />
<ClInclude Include="..\Include\EGkIntersLineSphere.h" />
@@ -448,7 +451,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="..\Include\EGkLineTgTwoCurves.h" />
<ClInclude Include="..\Include\EGkLuaAux.h" />
<ClInclude Include="..\Include\EGkMaterial.h" />
<ClInclude Include="..\Include\EgkObjGraphics.h" />
<ClInclude Include="..\Include\EGkObjGraphics.h" />
<ClInclude Include="..\Include\EGkOffsetCurve.h" />
<ClInclude Include="..\Include\EGkOffsetCurveOnX.h" />
<ClInclude Include="..\Include\EGkPlane3d.h" />
@@ -465,24 +468,40 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
<ClInclude Include="..\Include\EGkStringUtils3d.h" />
<ClInclude Include="..\Include\EGkSurf.h" />
<ClInclude Include="..\Include\EGkSurfFlatRegion.h" />
<ClInclude Include="..\Include\EgkSurfTriMesh.h" />
<ClInclude Include="..\Include\EGkSurfTriMesh.h" />
<ClInclude Include="..\Include\EGkTriangle3d.h" />
<ClInclude Include="..\Include\EGkUiUnits.h" />
<ClInclude Include="..\Include\EGkUserObj.h" />
<ClInclude Include="..\Include\EGkUserObjFactory.h" />
<ClInclude Include="..\Include\EGkVector3d.h" />
<ClInclude Include="..\Include\EgkVolZmap.h" />
<ClInclude Include="..\Include\EgnGetModuleVer.h" />
<ClInclude Include="..\Include\EGkVolZmap.h" />
<ClInclude Include="..\Include\EGnCmdExecutor.h" />
<ClInclude Include="..\Include\EGnCmdParser.h" />
<ClInclude Include="..\Include\EGnFileUtils.h" />
<ClInclude Include="..\Include\EGnGetModuleVer.h" />
<ClInclude Include="..\Include\EGnLuaAux.h" />
<ClInclude Include="..\Include\EGnScanner.h" />
<ClInclude Include="..\Include\EGnStringKeyVal.h" />
<ClInclude Include="..\Include\EGnStringUtils.h" />
<ClInclude Include="..\Include\EgtExecMgr.h" />
<ClInclude Include="..\Include\EgtFunPtrType.h" />
<ClInclude Include="..\Include\EgtILogger.h" />
<ClInclude Include="..\Include\EgtKeyCodes.h" />
<ClInclude Include="..\Include\EgtLibVer.h" />
<ClInclude Include="..\Include\EgtLogger.h" />
<ClInclude Include="..\Include\EgtNumCollection.h" />
<ClInclude Include="..\Include\EgtNumUtils.h" />
<ClInclude Include="..\Include\EgtPerfCounter.h" />
<ClInclude Include="..\Include\EgtPointerOwner.h" />
<ClInclude Include="..\Include\EgtStringBase.h" />
<ClInclude Include="..\Include\EgtStringConverter.h" />
<ClInclude Include="..\Include\EgtStringDecoder.h" />
<ClInclude Include="..\Include\EgtStringEncoder.h" />
<ClInclude Include="..\Include\EgtTargetVer.h" />
<ClInclude Include="..\Include\EgtTrace.h" />
<ClInclude Include="..\Include\ENkCplxCollection.h" />
<ClInclude Include="..\Include\ENkPolynomial.h" />
<ClInclude Include="..\Include\ENkPolynomialRoots.h" />
<ClInclude Include="BiArcs.h" />
<ClInclude Include="CalcDerivate.h" />
<ClInclude Include="CAvSimpleSurfFrMove.h" />
EgtGeomKernel.vcxproj.filters
+69 -12
View File
@@ -644,9 +644,6 @@
<ClInclude Include="..\Include\EGkMaterial.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgkObjGraphics.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkPlane3d.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
@@ -665,18 +662,12 @@
<ClInclude Include="..\Include\EGkStringUtils3d.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgkSurfTriMesh.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkVector3d.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\ENkPolynomial.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgnGetModuleVer.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGnStringUtils.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
@@ -722,9 +713,6 @@
<ClInclude Include="VolZmap.h">
<Filter>File di intestazione</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgkVolZmap.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkStmFromCurves.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
@@ -890,6 +878,75 @@
<ClInclude Include="..\Include\EGkIntersTriaTria.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkVolZmap.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGnGetModuleVer.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkSurfTriMesh.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkObjGraphics.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkDistPointSurfTm.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkHashGrids2d.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGkHashGrids3d.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGnLuaAux.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGnCmdExecutor.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGnCmdParser.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EGnFileUtils.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\ENkCplxCollection.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\ENkPolynomialRoots.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtStringBase.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtStringConverter.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtStringDecoder.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtStringEncoder.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtNumCollection.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtNumUtils.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtKeyCodes.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtLibVer.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtExecMgr.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
<ClInclude Include="..\Include\EgtFunPtrType.h">
<Filter>File di intestazione\Include</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="EgtGeomKernel.rc">
GdbExecutor.cpp
+142 -142
View File
@@ -19,6 +19,8 @@
#include "GeoConst.h"
#include "GeomDB.h"
#include "DllMain.h"
#include "CurveLine.h"
#include "SurfTriMesh.h"
#include "VolZmap.h"
#include "IntersLineSurfStd.h"
#include "CAvToolTriangle.h"
@@ -27,7 +29,6 @@
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkGeoFrame3d.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkLinePntTgCurve.h"
#include "/EgtDev/Include/EGkLineTgTwoCurves.h"
@@ -44,7 +45,6 @@
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/EGkBiArcs.h"
#include "/EgtDev/Include/EGkCurveByInterp.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
@@ -3142,25 +3142,25 @@ GdbExecutor::LineDiscInters( const STRVECTOR& vsParams)
if ( nIntType == D_NO_INTERS)
int nSol = 0 ;
if ( nIntType == D_BOUNDARY_INT_LINE_NOT_IN_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_INNER_INT_LINE_NOT_IN_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_ONE_INT_LINE_ON_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 5 * vtLine, ptPS + 5 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_INFINITE_INT_LINE_ON_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3212,25 +3212,25 @@ GdbExecutor::RayDiscInters( const STRVECTOR& vsParams)
if ( nIntType == D_NO_INTERS)
int nSol = 0 ;
if ( nIntType == D_BOUNDARY_INT_LINE_NOT_IN_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_INNER_INT_LINE_NOT_IN_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_ONE_INT_LINE_ON_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 5 * vtLine, ptPS + 5 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_INFINITE_INT_LINE_ON_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3286,25 +3286,25 @@ GdbExecutor::SegmentDiscInters( const STRVECTOR& vsParams)
if ( nIntType == D_NO_INTERS)
int nSol = 0 ;
if ( nIntType == D_BOUNDARY_INT_LINE_NOT_IN_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_INNER_INT_LINE_NOT_IN_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_ONE_INT_LINE_ON_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 5 * vtLine, ptPS + 5 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == D_INFINITE_INT_LINE_ON_PLANE) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3351,13 +3351,13 @@ GdbExecutor::LineSphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_NO_INTERS)
int nSol = 0 ;
if ( nIntType == S_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3404,19 +3404,19 @@ GdbExecutor::RaySphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_NO_INTERS)
int nSol = 0 ;
if ( nIntType == S_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtV, ptPS + 3 * vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3468,21 +3468,21 @@ GdbExecutor::SegmentSphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_TWO_INT) {
Point3d ptPS = ptP + dU1 * vtV ;
Point3d ptPE = ptP + dU2 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
Point3d ptPS = ptP + dU1 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_SEC) {
Point3d ptPS = ptP + dU1 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtV, ptPS + 3 * vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3535,13 +3535,13 @@ GdbExecutor::LineSemiSphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_NO_INTERS)
int nSol = 0 ;
if ( nIntType == S_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3594,19 +3594,19 @@ GdbExecutor::RaySemiSphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_NO_INTERS)
int nSol = 0 ;
if ( nIntType == S_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3663,21 +3663,21 @@ GdbExecutor::SegmentSemiSphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_TWO_INT) {
Point3d ptPS = ptP + dU1 * vtV ;
Point3d ptPE = ptP + dU2 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
Point3d ptPS = ptP + dU1 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_SEC) {
Point3d ptPS = ptP + dU1 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtV, ptPS + 3 * vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3736,21 +3736,21 @@ GdbExecutor::LinCompSemiSphereInters( const STRVECTOR& vsParams)
if ( nIntType == S_TWO_INT) {
Point3d ptPS = ptP + dU1 * vtV ;
Point3d ptPE = ptP + dU2 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj (vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_TAN) {
Point3d ptPS = ptP + dU1 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtV, ptPS + vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nIntType == S_ONE_INT_SEC) {
Point3d ptPS = ptP + dU1 * vtV ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtV, ptPS + 3 * vtV) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3803,25 +3803,25 @@ GdbExecutor::LineInfiniteCylinderInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3874,25 +3874,25 @@ GdbExecutor::RayInfiniteCylinderInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -3948,25 +3948,25 @@ GdbExecutor::SegmentInfiniteCylinderInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4026,25 +4026,25 @@ GdbExecutor::SegmentCylinderInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4104,31 +4104,31 @@ GdbExecutor::SegmentConeInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ON_VERT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 6 * vtLine, ptPS + 6 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4187,31 +4187,31 @@ GdbExecutor::LineTruncateConeInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ON_VERT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 6 * vtLine, ptPS + 6 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4271,31 +4271,31 @@ GdbExecutor::RayTruncateConeInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ON_VERT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 6 * vtLine, ptPS + 6 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4358,31 +4358,31 @@ GdbExecutor::SegmentTruncateConeInters( const STRVECTOR& vsParams)
if ( nTypeInt == CC_NO_INTERS)
int nSol = 0 ;
if ( nTypeInt == CC_ONE_INT_SEC) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 3 * vtLine, ptPS + 3 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ONE_INT_TAN) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - vtLine, ptPS + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_TWO_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_INF_INT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS, ptPE) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == CC_ON_VERT) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptPS - 6 * vtLine, ptPS + 6 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4437,7 +4437,7 @@ GdbExecutor::LineTorusInters( const STRVECTOR& vsParams)
int nSol = 0 ;
if ( nTypeInt == T_ONE_TAN) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - vtLine, ptInt + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4445,8 +4445,8 @@ GdbExecutor::LineTorusInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_TAN) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
pLine1->Set( ptInt1 - vtLine, ptInt1 + vtLine) ;
// inserisco nel DB
@@ -4456,7 +4456,7 @@ GdbExecutor::LineTorusInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_SEC) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt0, ptInt1) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4466,24 +4466,24 @@ GdbExecutor::LineTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
if ( vbT[0] && vbT[1] && ( ! vbT[2])) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0, ptInt1) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt2 - vtLine, ptInt2 + vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
AddGeoObj( "$NN", vsParams[1], Release( pLine1))) ;
}
else if ( vbT[0] && ( ! vbT[1]) && vbT[2]) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt0, ptInt2) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
else if ( ( ! vbT[0]) && vbT[1] && vbT[2]) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1, ptInt2) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4495,9 +4495,9 @@ GdbExecutor::LineTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
Point3d ptInt3 = ptLine + vdP[3] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0, ptInt1) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt2, ptInt3) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4554,14 +4554,14 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
int nSol = 0 ;
if ( nTypeInt == T_ONE_TAN) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - vtLine, ptInt + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == T_ONE_SEC) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - 4 * vtLine, ptInt + 4 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4569,8 +4569,8 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_TAN) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
pLine1->Set( ptInt1 - vtLine, ptInt1 + vtLine) ;
// inserisco nel DB
@@ -4580,7 +4580,7 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_SEC) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt0, ptInt1) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4590,9 +4590,9 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
double dDil0 = ( vbT[0] ? 4 : 1) ;
double dDil1 = ( vbT[1] ? 4 : 1) ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - dDil0 * vtLine, ptInt0 + dDil0 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - dDil1 * vtLine, ptInt1 + dDil1 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4602,11 +4602,11 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4618,24 +4618,24 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
if ( vbT[0] && vbT[1] && ( ! vbT[2])) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0, ptInt1) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt2 - vtLine, ptInt2 + vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
AddGeoObj( "$NN", vsParams[1], Release( pLine1))) ;
}
else if ( vbT[0] && ( ! vbT[1]) && vbT[2]) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt0, ptInt2) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
else if ( ( ! vbT[0]) && vbT[1] && vbT[2]) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1, ptInt2) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4647,9 +4647,9 @@ GdbExecutor::RayTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
Point3d ptInt3 = ptLine + vdP[3] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0, ptInt1) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt2, ptInt3) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4710,14 +4710,14 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
int nSol = 0 ;
if ( nTypeInt == T_ONE_TAN) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - vtLine, ptInt + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == T_ONE_SEC) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - 4 * vtLine, ptInt + 4 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4725,8 +4725,8 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_TAN) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
pLine1->Set( ptInt1 - vtLine, ptInt1 + vtLine) ;
// inserisco nel DB
@@ -4736,8 +4736,8 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_SEC) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
// inserisco nel DB
@@ -4749,9 +4749,9 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
double dDil0 = ( vbT[0] ? 4 : 1) ;
double dDil1 = ( vbT[1] ? 4 : 1) ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - dDil0 * vtLine, ptInt0 + dDil0 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - dDil1 * vtLine, ptInt1 + dDil1 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4761,11 +4761,11 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4777,11 +4777,11 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
if ( vbT[0] && vbT[1] && ( ! vbT[2])) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - vtLine, ptInt2 + vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4789,11 +4789,11 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
AddGeoObj( "$NN", vsParams[1], Release( pLine2))) ;
}
else if ( vbT[0] && ( ! vbT[1]) && vbT[2]) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - vtLine, ptInt1 + vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4801,11 +4801,11 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
AddGeoObj( "$NN", vsParams[1], Release( pLine2))) ;
}
else if ( ( ! vbT[0]) && vbT[1] && vbT[2]) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4818,9 +4818,9 @@ GdbExecutor::SegmentTorusInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
Point3d ptInt3 = ptLine + vdP[3] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0, ptInt1) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt2, ptInt3) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4884,14 +4884,14 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
int nSol = 0 ;
if ( nTypeInt == T_ONE_TAN) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - vtLine, ptInt + vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
}
if ( nTypeInt == T_ONE_SEC) {
Point3d ptInt = ptLine + vdP[0] * vtLine ;
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptInt - 4 * vtLine, ptInt + 4 * vtLine) ;
// inserisco nel DB
return AddGeoObj( vsParams[0], vsParams[1], Release( pLine)) ;
@@ -4899,8 +4899,8 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_TAN) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
pLine1->Set( ptInt1 - vtLine, ptInt1 + vtLine) ;
// inserisco nel DB
@@ -4910,8 +4910,8 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
if ( nTypeInt == T_TWO_SEC) {
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
// inserisco nel DB
@@ -4923,9 +4923,9 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
double dDil0 = ( vbT[0] ? 4 : 1) ;
double dDil1 = ( vbT[1] ? 4 : 1) ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - dDil0 * vtLine, ptInt0 + dDil0 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - dDil1 * vtLine, ptInt1 + dDil1 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4935,11 +4935,11 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
Point3d ptInt0 = ptLine + vdP[0] * vtLine ;
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4951,11 +4951,11 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
if ( vbT[0] && vbT[1] && ( ! vbT[2])) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - vtLine, ptInt2 + vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4963,11 +4963,11 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
AddGeoObj( "$NN", vsParams[1], Release( pLine2))) ;
}
else if ( vbT[0] && ( ! vbT[1]) && vbT[2]) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - 4 * vtLine, ptInt0 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - vtLine, ptInt1 + vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4975,11 +4975,11 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
AddGeoObj( "$NN", vsParams[1], Release( pLine2))) ;
}
else if ( ( ! vbT[0]) && vbT[1] && vbT[2]) {
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0 - vtLine, ptInt0 + vtLine) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt1 - 4 * vtLine, ptInt1 + 4 * vtLine) ;
PtrOwner<CurveLine> pLine2( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine2( CreateBasicCurveLine()) ;
pLine2->Set( ptInt2 - 4 * vtLine, ptInt2 + 4 * vtLine) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -4992,9 +4992,9 @@ GdbExecutor::LinCompTorusPartInters( const STRVECTOR& vsParams)
Point3d ptInt1 = ptLine + vdP[1] * vtLine ;
Point3d ptInt2 = ptLine + vdP[2] * vtLine ;
Point3d ptInt3 = ptLine + vdP[3] * vtLine ;
PtrOwner<CurveLine> pLine0( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine0( CreateBasicCurveLine()) ;
pLine0->Set( ptInt0, ptInt1) ;
PtrOwner<CurveLine> pLine1( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine1( CreateBasicCurveLine()) ;
pLine1->Set( ptInt2, ptInt3) ;
// inserisco nel DB
return ( AddGeoObj( vsParams[0], vsParams[1], Release( pLine0)) &&
@@ -5084,7 +5084,7 @@ GdbExecutor::ExecuteDistPointTrimesh( const std::string& sCmd2, const STRVECTOR&
if ( DistPointSurf.GetMinDistPoint( ptMinDistPoint) ) {
PtrOwner<CurveLine> pLine( new( nothrow) CurveLine) ;
PtrOwner<CurveLine> pLine( CreateBasicCurveLine()) ;
pLine->Set( ptP, ptMinDistPoint) ;
Vector3d vtDir = ptP - ptMinDistPoint ;
VolZmap.h
+7 -15
View File
@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------
// EgalTech 2015-2019
//----------------------------------------------------------------------------
// File : VolZmap.h Data : 07.03.19 Versione : 2.1c2
// File : VolZmap.h Data : 12.05.19 Versione : 2.1e3
// Contenuto : Dichiarazione della classe Volume Zmap.
//
//
@@ -15,15 +15,8 @@
#include "ObjGraphicsMgr.h"
#include "GeoObjRW.h"
#include "CurveComposite.h"
#include "SurfFlatRegion.h"
#include "CurveLine.h"
#include "Tool.h"
#include "/EgtDev/Include/EGkVolZmap.h"
#include "/EgtDev/Include/EGkPoint3d.h"
#include "/EgtDev/Include/EGkVector3d.h"
#include "/EgtDev/Include/ENkPolynomialRoots.h"
#include "/EgtDev/Include/EgkIntersLinesurfTm.h"
#include <unordered_map>
#include <stack>
@@ -97,8 +90,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) override ;
bool GetDepth( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bExact) const override ;
bool GetDepthWithDexel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) const ;
bool GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength, bool bEnh) const ;
bool GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const override ;
bool GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) const override ;
bool AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag, double dSafeDist) const override ;
bool AvoidSphere( const Point3d& ptCenter, double dRad, double dSafeDist) const override ;
@@ -108,7 +100,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool Cut( const Plane3d& plPlane) override ;
bool Compact( void) override ;
public : // IGeoObjRW
int GetNgeId( void) const override ;
bool Save( NgeWriter& ngeOut) const override ;
@@ -188,7 +179,6 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool CalcDexelPrisms( int nPos1, int nPos2, int nBlock) const ;
bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ,
const Vector3d& vtZ, const Vector3d& vtNorm, int nBlock) const ;
bool ProcessCell( int nGrid, int nCellI, int nCellJ, const Plane3d& plPlane, std::vector<CurveLine>& vLine) const ;
bool UpdateSingleMapGraphics( void) const ;
bool UpdateTripleMapGraphics( void) const ;
bool ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const ;
@@ -198,13 +188,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool FlipEdgesII( int nBlock) const ;
bool FlipEdgesBB() const ;
bool IsThereMat( int nI, int nJ, int nK) const ;
bool InOut( const Plane3d& plPlane, int nGrid, int nI, int nJ) const ;
int CalcIndex( int nI, int nJ, int nK) const ;
int CalcIndexForPlaneCells( const Plane3d& plPlane, int nGrid, int nCellI, int nCellJ) const ;
bool IntersPos( int nVec1[], int nVec2[], bool bFirstCorner, AppliedVector& vfField) const ;
bool IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, double dPrec = EPS_SMALL) const ;
bool GetPointVoxel( const Point3d& ptP, int& nVoxI, int& nVoxJ, int& nVoxK) const ;
bool IsZInsideInterval( int nGrid, int nDex, double dZ) const ;
// Per regolarizzazione della catena di feature
bool FindAdjComp( const std::vector<VoxelContainer>& vVecVox, int nCurBlock, int nCurVox, int nCurComp,
INTVECTOR& vAdjBlockVoxComp, INTVECTOR& vAdjBordBlockVoxComp) const ;
@@ -299,6 +286,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
double& dU1, double& dU2) const ;
bool IntersRayDexel( const Point3d& ptP, const Vector3d& vtV, int nGrid, int nI, int nJ,
double& dU1, double& dU2) const ;
bool GetDepthWithDexel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) const ;
bool GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) const ;
bool IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
const Frame3d& CylFrame, double dH, double dRad, bool bTapLow, bool bTapUp,
Point3d& ptInt1, Vector3d& vtN1, Point3d& ptInt2, Vector3d& vtN2) const ;
@@ -318,11 +307,14 @@ class VolZmap : public IVolZmap, public IGeoObjRW
bool IsValidVoxel( int nI, int nJ, int nK) const ;
bool GetVoxIJKFromN( int nN, int& nI, int& nJ, int& nK) const ;
bool GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const ;
bool GetVoxelBox( int nI, int nJ, int nK, BBox3d& b3VoxBox) const ;
// Funzioni di gestione dei blocchi
bool GetBlockIJKFromN( int nBlock, int nIJK[]) const ;
bool GetBlockNFromIJK( int nIJK[], int& nBlock) const ;
bool GetBlockLimitsIJK( const int nIJK[], int nLimits[]) const ;
bool GetBlockBox( const int nIJK[], BBox3d& b3VoxBox) const ;
bool GetVoxelBlockIJK( const int nVoxIJK[], int nBlockIJK[]) const ;
bool GetVoxelBlockN( int nVox, int& nBlock) const ;
bool SetToModifyDexelBlocks( int nGrid, int nDex, int nInt) ;
bool GetAdjBlockToBlock( int nBlockN, int nDeltaI, int nDeltaJ, int nDeltaK, int& nAdjBlockN) const ;
bool IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], bool bType) const ;
VolZmapCalculus.cpp
+368 -540
View File
@@ -19,11 +19,47 @@
#include "/EgtDev/Include/EGkIntersLineTria.h"
#include "/EgtDev/Include/EGkIntersLinePlane.h"
#include "/EgtDev/Include/EGkIntersLineSphere.h"
#include "/EgtDev/Include/EGkIntersPlaneTria.h"
#include "/EgtDev/Include/EGkChainCurves.h"
#include "/EgtDev/Include/ENkPolynomialRoots.h"
#include "/EgtDev/Include/EgtNumUtils.h"
using namespace std ;
//----------------------------------------------------------------------------
// Box e piano devono essere nello stesso riferimento. Il box deve essere axis aligned.
static bool
TestIntersPlaneBox( const BBox3d& b3Box, const Plane3d& plPlane)
{
// Calcolo le distanze con segno dei punti dal piano
Point3d ptE0 = b3Box.GetMin() ;
double dDist0 = DistPointPlane( ptE0, plPlane) ;
Point3d ptE1( b3Box.GetMax().x, b3Box.GetMin().y, b3Box.GetMin().z) ;
double dDist1 = DistPointPlane( ptE1, plPlane) ;
Point3d ptE2( b3Box.GetMax().x, b3Box.GetMax().y, b3Box.GetMin().z) ;
double dDist2 = DistPointPlane( ptE2, plPlane) ;
Point3d ptE3( b3Box.GetMin().x, b3Box.GetMax().y, b3Box.GetMin().z) ;
double dDist3 = DistPointPlane( ptE3, plPlane) ;
Point3d ptE4( b3Box.GetMin().x, b3Box.GetMin().y, b3Box.GetMax().z) ;
double dDist4 = DistPointPlane( ptE4, plPlane) ;
Point3d ptE5( b3Box.GetMax().x, b3Box.GetMin().y, b3Box.GetMax().z) ;
double dDist5 = DistPointPlane( ptE5, plPlane) ;
Point3d ptE6 = b3Box.GetMax() ;
double dDist6 = DistPointPlane( ptE6, plPlane) ;
Point3d ptE7( b3Box.GetMin().x, b3Box.GetMax().y, b3Box.GetMax().z) ;
double dDist7 = DistPointPlane( ptE7, plPlane) ;
// Distanze tutte positive
if ( dDist0 > EPS_SMALL && dDist1 > EPS_SMALL && dDist2 > EPS_SMALL && dDist3 > EPS_SMALL &&
dDist4 > EPS_SMALL && dDist5 > EPS_SMALL && dDist6 > EPS_SMALL && dDist7 > EPS_SMALL)
return false ;
// Distanze tutte negative
if ( dDist0 < - EPS_SMALL && dDist1 < - EPS_SMALL && dDist2 < - EPS_SMALL && dDist3 < - EPS_SMALL &&
dDist4 < - EPS_SMALL && dDist5 < - EPS_SMALL && dDist6 < - EPS_SMALL && dDist7 < - EPS_SMALL)
return false ;
// Il piano interseca il box
return true ;
}
//----------------------------------------------------------------------------
// Punti e vettore devono esse espressi nel medesimo sistema di riferimento.
// Il box è allineato con gli assi di tale sistema di riferimento.
@@ -31,7 +67,6 @@ using namespace std ;
bool
VolZmap::IntersLineBox( const Point3d& ptP, const Vector3d& vtV, const Point3d& ptMin, const Point3d& ptMax) const
{
// Il box è allineato agli assi
double dU1, dU2 ;
return IntersLineBox( ptP, vtV, ptMin, ptMax, dU1, dU2) ;
}
@@ -219,7 +254,7 @@ VolZmap::GetDepth( const Point3d& ptPLoc, const Vector3d& vtDLoc, double& dInLen
vtD.ToLoc( m_MapFrame) ;
if ( bExact && m_nMapNum == 3)
return GetDepthWithVoxel( ptP, vtD, dInLength, dOutLength, true) ;
return GetDepthWithVoxel( ptP, vtD, dInLength, dOutLength) ;
else
return GetDepthWithDexel( ptP, vtD, dInLength, dOutLength) ;
}
@@ -385,286 +420,73 @@ VolZmap::GetDepthWithDexel( const Point3d& ptP, const Vector3d& vtV, double& dIn
//----------------------------------------------------------------------------
// Calcola la profondità del materiale usando i triangoli della rappresentazione grafica.
// Punto e versore devono essere espressi nel sistema di riferimento Zmap.
// Se si vuole che vengano utilizzati i triangoli con sharp-featue bEnh deve valere true, false altrimenti.
// InLength = distanza di ingresso (se -1 il punto è interno, se -2 il punto è esterno e il raggio non interseca lo Zmap)
// OutLength = distanza di uscita.
bool
VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength, bool bEnh) const
VolZmap::GetDepthWithVoxel( const Point3d& ptP, const Vector3d& vtD, double& dInLength, double& dOutLength) const
{
// Serve che punto e vettore siano espressi sia nel sistema intrinseco dello Zmap (m_MapFrame) sia in quello
// in cui esso è immerso; questo perché i dexel sono espressi in quello intrinseco e i triangoli in quello
// in cui esso è immerso.
Point3d ptOutP = ptP ;
Vector3d vtOutD = vtD ;
ptOutP.ToGlob( m_MapFrame) ;
vtOutD.ToGlob( m_MapFrame) ;
// Intersezione fra semiretta e BBox dello Zmap
double dU1, dU2 ;
bool bLineBBoxInters = IntersLineZMapBBox( ptP, vtD, dU1, dU2) && ( dU1 > 0 || dU2 > 0) ;
ILZIVECTOR vIntersInfo ;
if ( ! GetLineIntersection( ptP, vtD, vIntersInfo))
return false ;
// Semiretta esterna al box dello Zmap quindi esterna anche allo Zmap
if ( ! bLineBBoxInters) {
dInLength = - 2 ;
dOutLength = - 2 ;
if ( vIntersInfo.empty()) {
dInLength = - 2. ;
dOutLength = - 2. ;
return true ;
}
// Lancio eventuale aggiornamento pendente della grafica
if ( m_nMapNum == 1)
UpdateSingleMapGraphics() ;
else
UpdateTripleMapGraphics() ;
// Determino il voxel di partenza
int nVoxI, nVoxJ, nVoxK ;
if ( ! GetPointVoxel( ptP, nVoxI, nVoxJ, nVoxK)) {
if ( ! GetPointVoxel( ptP + dU1 * vtD, nVoxI, nVoxJ, nVoxK))
return false ;
}
// Incrementi degli indici per seguire la retta
int nDeltaI = ( vtD.x > 0 ? 1 : ( vtD.x < 0 ? - 1 : 0)) ;
int nDeltaJ = ( vtD.y > 0 ? 1 : ( vtD.y < 0 ? - 1 : 0)) ;
int nDeltaK = ( vtD.z > 0 ? 1 : ( vtD.z < 0 ? - 1 : 0)) ;
// Scelgo i piani del voxel con cui intersecare la retta, per determinare il voxel successivo
int nPlaneI = ( vtD.x >= 0 ? 1 : 0) ;
int nPlaneJ = ( vtD.y >= 0 ? 1 : 0) ;
int nPlaneK = ( vtD.z >= 0 ? 1 : 0) ;
// Ciclo sui voxel
vector<VoxelIndexes> vVox ;
while ( IsValidVoxel( nVoxI, nVoxJ, nVoxK)) {
// Estremi della diagonale del voxel corrente
Point3d ptMin( ( nVoxI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nVoxJ * N_DEXVOXRATIO + 0.5) * m_dStep,
( nVoxK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptMax( ( ( nVoxI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nVoxJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nVoxK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
// Studio il voxel corrente
if ( IntersLineBox( ptP, vtD, ptMin, ptMax)) {
int nCurVoxIndex = CalcIndex( nVoxI, nVoxJ, nVoxK) ;
if ( nCurVoxIndex != 0 && nCurVoxIndex != 255) {
VoxelIndexes NewVox ;
NewVox.nI = nVoxI ;
NewVox.nJ = nVoxJ ;
NewVox.nK = nVoxK ;
vVox.emplace_back( NewVox) ;
}
}
// Interseco la retta con i piani frontiera del voxel
double dMaxTX = ( abs( vtD.x) > EPS_ZERO ?
abs( ( ( ( nVoxI + nPlaneI) * N_DEXVOXRATIO + 0.5) * m_dStep - ptP.x) / vtD.x) : INFINITO) ;
double dMaxTY = ( abs( vtD.y) > EPS_ZERO ?
abs( ( ( ( nVoxJ + nPlaneJ) * N_DEXVOXRATIO + 0.5) * m_dStep - ptP.y) / vtD.y) : INFINITO) ;
double dMaxTZ = ( abs( vtD.z) > EPS_ZERO ?
abs( ( ( ( nVoxK + nPlaneK) * N_DEXVOXRATIO + 0.5) * m_dStep - ptP.z) / vtD.z) : INFINITO) ;
// Determino gli incrementi
if ( dMaxTX < dMaxTY) {
if ( dMaxTX < dMaxTZ)
nVoxI += nDeltaI ;
else
nVoxK += nDeltaK ;
}
else {
if ( dMaxTY < dMaxTZ)
nVoxJ += nDeltaJ ;
else
nVoxK += nDeltaK ;
}
}
// Dati dell'intersezione
struct LineTriaInt {
int nNum ;
double dPar1 ;
double dPar2 ;
double dDot ;
LineTriaInt( void) : nNum( 0) {}
LineTriaInt( double dP, double dD) : nNum( 1), dPar1( dP), dDot( dD) {}
LineTriaInt( double dP1, double dP2, double dD)
: nNum( 2), dPar1( dP1), dPar2( dP2), dDot( dD) {}
} ;
vector<LineTriaInt> vInt ;
int nPrevBlockN = - 1 ;
// Ciclo sui voxel
for ( int nVx = 0 ; nVx < int( vVox.size()) ; ++ nVx) {
int nCurVoxIJK[3] = { vVox[nVx].nI, vVox[nVx].nJ, vVox[nVx].nK} ;
int nCurBlockIJK[3] ;
if ( GetVoxelBlockIJK( nCurVoxIJK, nCurBlockIJK)) {
int nCurBlockN ;
GetBlockNFromIJK( nCurBlockIJK, nCurBlockN) ;
// Triangoli sharp fra blocchi
for ( int nBlVx = 0 ; nBlVx < int( m_InterBlockSharpTria[nCurBlockN].size()) ; ++ nBlVx) {
if ( m_InterBlockSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] &&
m_InterBlockSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] &&
m_InterBlockSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) {
for ( int nBlCm = 0 ; nBlCm < int( m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) {
for ( int nBlTr = 0 ; nBlTr < int( m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) {
Triangle3d CurrTria = m_InterBlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT ||
nIntType == ILTT_EDGE ||
nIntType == ILTT_IN) {
vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ;
}
// altrimenti ci sono due intersezioni
else {
double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ;
double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ;
double dD = vtOutD * CurrTria.GetN() ;
vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ;
}
}
}
}
}
// Triangoli sharp interni
for ( int nBlVx = 0 ; nBlVx < int( m_BlockSharpTria[nCurBlockN].size()) ; ++ nBlVx) {
if ( m_BlockSharpTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] &&
m_BlockSharpTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] &&
m_BlockSharpTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) {
for ( int nBlCm = 0 ; nBlCm < int( m_BlockSharpTria[nCurBlockN][nBlVx].vCompoTria.size()) ; ++ nBlCm) {
for ( int nBlTr = 0 ; nBlTr < int( m_BlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm].size()) ; ++ nBlTr) {
Triangle3d CurrTria = m_BlockSharpTria[nCurBlockN][nBlVx].vCompoTria[nBlCm][nBlTr] ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT ||
nIntType == ILTT_EDGE ||
nIntType == ILTT_IN) {
vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ;
}
// altrimenti ci sono due intersezioni
else {
double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ;
double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ;
double dD = vtOutD * CurrTria.GetN() ;
vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ;
}
}
}
}
}
// Triangoli smooth
for ( int nBlVx = 0 ; nBlVx < int( m_BlockSmoothTria[nCurBlockN].size()) ; ++ nBlVx) {
if ( m_BlockSmoothTria[nCurBlockN][nBlVx].i == nCurVoxIJK[0] &&
m_BlockSmoothTria[nCurBlockN][nBlVx].j == nCurVoxIJK[1] &&
m_BlockSmoothTria[nCurBlockN][nBlVx].k == nCurVoxIJK[2]) {
for ( int nBlTr = 0 ; nBlTr < int( m_BlockSmoothTria[nCurBlockN][nBlVx].vTria.size()) ; ++ nBlTr) {
Triangle3d CurrTria = m_BlockSmoothTria[nCurBlockN][nBlVx].vTria[nBlTr] ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT ||
nIntType == ILTT_EDGE ||
nIntType == ILTT_IN) {
vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ;
}
// altrimenti ci sono due intersezioni
else {
double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ;
double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ;
double dD = vtOutD * CurrTria.GetN() ;
vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ;
}
}
}
}
// Triangoli grandi
if ( nCurBlockN != nPrevBlockN) {
for ( int nBlTr = 0 ; nBlTr < int( m_BlockBigTria[nCurBlockN].size()) ; ++ nBlTr) {
Triangle3d CurrTria = m_BlockBigTria[nCurBlockN][nBlTr] ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptOutP, vtOutD, 1.5 * dU2, CurrTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT ||
nIntType == ILTT_EDGE ||
nIntType == ILTT_IN) {
vInt.emplace_back( ( ptLineTria1 - ptOutP) * vtOutD, vtOutD * CurrTria.GetN()) ;
}
// altrimenti ci sono due intersezioni
else {
double dP1 = ( ptLineTria1 - ptOutP) * vtOutD ;
double dP2 = ( ptLineTria2 - ptOutP) * vtOutD ;
double dD = vtOutD * CurrTria.GetN() ;
vInt.emplace_back( ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1), dD) ;
}
}
nPrevBlockN = nCurBlockN ;
}
}
}
// Ordino le intersezioni in base al parametro distanza con segno da ptP
sort( vInt.begin(), vInt.end(),
[]( const LineTriaInt& a, const LineTriaInt& b)
{ double dFP = ( a.nNum == 2 ? 0.5 * ( a.dPar1 + a.dPar2) : a.dPar1) ;
double dLP = ( b.nNum == 2 ? 0.5 * ( b.dPar1 + b.dPar2) : b.dPar1) ;
return ( dLP > dFP) ; }) ;
// Inizializzo le distanze di ingresso e uscita:
// dInLength diminuisce, dOutLength aumenta.
dInLength = INFINITO ;
dOutLength = - INFINITO ;
// Porto nel riferimento intrinseco dello Zmap
Vector3d vtOutD = vtD ;
vtOutD.ToGlob( m_MapFrame) ;
// Inizializzo le distanze di ingresso e uscita:
// dInLength diminuisce, dOutLength aumenta.
dInLength = INFINITO ;
dOutLength = -INFINITO ;
int nFirstPosN ;
int nN = 0 ;
for ( ; nN < int( vInt.size()) ; ++ nN) {
if ( vInt[nN].dPar1 > - EPS_SMALL) {
for ( ; nN < int( vIntersInfo.size()) ; ++ nN) {
if ( vIntersInfo[nN].dU > - EPS_SMALL) {
nFirstPosN = nN ;
break ;
break ;
}
}
if ( nN == int( vInt.size())) {
if ( nN == int( vIntersInfo.size())) {
dInLength = - 2 ;
dOutLength = - 2 ;
return true ;
}
if ( nFirstPosN > 0) {
if ( vInt[nFirstPosN - 1].dDot < EPS_ZERO)
dInLength = -1 ;
int nVoxIJK[3] ;
GetBlockIJKFromN( vIntersInfo[0].nVox, nVoxIJK) ;
if ( nFirstPosN > 0) {
if ( vIntersInfo[nFirstPosN - 1].trTria.GetN() * vtOutD < EPS_ZERO)
dInLength = - 1 ;
}
else if ( nFirstPosN == 0) {
if ( vInt[nFirstPosN].dDot > EPS_ZERO)
dInLength = -1 ;
else if ( GetPointVoxel( ptP, nVoxI, nVoxJ, nVoxK)) {
int nCubeType = CalcIndex( nVoxI, nVoxJ, nVoxK) ;
if ( vIntersInfo[nFirstPosN].trTria.GetN() * vtOutD > EPS_ZERO)
dInLength = - 1 ;
else if ( GetPointVoxel( ptP, nVoxIJK[0], nVoxIJK[1], nVoxIJK[2])) {
int nCubeType = CalcIndex( nVoxIJK[0], nVoxIJK[1], nVoxIJK[2]) ;
if ( nCubeType == 255)
dInLength = -1 ;
dInLength = - 1 ;
}
}
for ( int nN = nFirstPosN ; nN < int( vInt.size()) ; ++ nN) {
if ( vInt[nN].dDot > - EPS_ZERO) {
if ( vInt[nN].nNum == 2 && dOutLength < vInt[nN].dPar2)
dOutLength = vInt[nN].dPar2 ;
else if ( dOutLength < vInt[nN].dPar1)
dOutLength = vInt[nN].dPar1 ;
}
if ( vInt[nN].dDot < EPS_ZERO &&
dInLength > vInt[nN].dPar1)
dInLength = vInt[nN].dPar1 ;
for ( int nN = nFirstPosN ; nN < int( vIntersInfo.size()) ; ++ nN) {
if ( vIntersInfo[nN].trTria.GetN() * vtOutD > - EPS_ZERO) {
if ( ( vIntersInfo[nN].nILTT == ILTT_SEGM || vIntersInfo[nN].nILTT == ILTT_SEGM_ON_EDGE) &&
dOutLength < vIntersInfo[nN].dU2)
dOutLength = vIntersInfo[nN].dU2 ;
else if ( dOutLength < vIntersInfo[nN].dU)
dOutLength = vIntersInfo[nN].dU ;
}
if ( vIntersInfo[nN].trTria.GetN() * vtOutD < EPS_ZERO &&
dInLength > vIntersInfo[nN].dU)
dInLength = vIntersInfo[nN].dU ;
}
return true ;
@@ -1502,6 +1324,193 @@ VolZmap::GetPartVolume( int nPart, double& dVol) const
return true ;
}
//----------------------------------------------------------------------------
// La retta deve essere espressa nel sistema Zmap.
// Per riferimento viene restituito un vettore di intersezioni della retta con i triangoli della superficie del solido.
// Si restituisce false in caso di errore, true altrimenti.
bool
VolZmap::GetLineIntersection( const Point3d& ptP, const Vector3d& vtD, ILZIVECTOR& vIntersInfo) const
{
// Calcolo punto e vettore espressi nel riferimento intrinseco dello Zmap
Point3d ptLocP = ptP ;
Vector3d vtLocD = vtD ;
ptLocP.ToLoc( m_MapFrame) ;
vtLocD.ToLoc( m_MapFrame) ;
// Intersezione fra semiretta e BBox dello Zmap
double dU1, dU2 ;
bool bLineBBoxInters = IntersLineZMapBBox( ptLocP, vtLocD, dU1, dU2) && ( dU1 > 0 || dU2 > 0) ;
// Semiretta esterna al box dello Zmap quindi esterna anche allo Zmap
if ( ! bLineBBoxInters)
return true ;
// Lancio eventuale aggiornamento pendente della grafica
if ( m_nMapNum == 1)
UpdateSingleMapGraphics() ;
else
UpdateTripleMapGraphics() ;
// Ciclo sui blocchi
for ( int nB = 0 ; nB < m_nNumBlock ; ++ nB) {
// Determino indici IJK del blocco; se non trovo il blocco, errore
int nBlockIJK[3] ;
if ( ! GetBlockIJKFromN( nB, nBlockIJK))
return false ;
// Costruisco il bounding-box del blocco; se non è possibile, errore
BBox3d b3BlockBox ;
if ( ! GetBlockBox( nBlockIJK, b3BlockBox))
return false ;
// Se c'è intersezione valuto tutti i voxel interni
if ( IntersLineBox( ptLocP, vtLocD, b3BlockBox.GetMin(), b3BlockBox.GetMax())) {
// Ciclo sui voxel del blocco.
// Triangoli smooth
for ( int nV = 0 ; nV < int( m_BlockSmoothTria[nB].size()) ; ++ nV) {
// Box del voxel
BBox3d b3Vox ;
int nCurVoxIJK[3] = { m_BlockSmoothTria[nB][nV].i,
m_BlockSmoothTria[nB][nV].j,
m_BlockSmoothTria[nB][nV].k } ;
GetVoxelBox( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], b3Vox) ;
// Se non c'è intersezione col voxel, passo al successivo.
if ( ! IntersLineBox( ptLocP, vtLocD, b3Vox.GetMin(), b3Vox.GetMax()))
continue ;
for ( int nT = 0 ; nT < int( m_BlockSmoothTria[nB][nV].vTria.size()) ; ++ nT) {
Triangle3d trTria = m_BlockSmoothTria[nB][nV].vTria[nT] ;
if ( ! trTria.Validate( true))
continue ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, trTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtD,
nNumVox, nB, ptLineTria1, trTria) ;
}
// altrimenti ci sono due intersezioni
else {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dP1 = ( ptLineTria1 - ptP) * vtD ;
double dP2 = ( ptLineTria2 - ptP) * vtD ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
}
}
}
// Triangoli sharp interni al blocco
for ( int nV = 0 ; nV < int( m_BlockSharpTria[nB].size()) ; ++ nV) {
int nCurVoxIJK[3] = { m_BlockSharpTria[nB][nV].i,
m_BlockSharpTria[nB][nV].j,
m_BlockSharpTria[nB][nV].k } ;
// Ciclo sulle componenti connesse
for ( int nC = 0 ; nC < int( m_BlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
for ( int nT = 0 ; nT < int( m_BlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
Triangle3d trTria = m_BlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
if ( ! trTria.Validate( true))
continue ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, trTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtD,
nNumVox, nB, ptLineTria1, trTria) ;
}
// altrimenti ci sono due intersezioni
else {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dP1 = ( ptLineTria1 - ptP) * vtD ;
double dP2 = ( ptLineTria2 - ptP) * vtD ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
}
}
}
}
// Triangoli grandi del blocco
for ( int nT = 0 ; nT < int( m_BlockBigTria[nB].size()) ; ++ nT) {
Triangle3d trTria = m_BlockBigTria[nB][nT] ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, trTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtD,
-1, nB, ptLineTria1, trTria) ;
}
// altrimenti ci sono due intersezioni
else {
double dP1 = ( ptLineTria1 - ptP) * vtD ;
double dP2 = ( ptLineTria2 - ptP) * vtD ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
-1, nB, ptLineTria1, ptLineTria2, trTria) ;
}
}
}
// In ogni caso valuto i triangoli sharp fra blocchi
for ( int nV = 0 ; nV < int( m_InterBlockSharpTria[nB].size()) ; ++ nV) {
int nCurVoxIJK[3] = { m_InterBlockSharpTria[nB][nV].i,
m_InterBlockSharpTria[nB][nV].j,
m_InterBlockSharpTria[nB][nV].k } ;
// Ciclo sulle componenti connesse
for ( int nC = 0 ; nC < int( m_InterBlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
for ( int nT = 0 ; nT < int( m_InterBlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
Triangle3d trTria = m_InterBlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
if ( ! trTria.Validate( true))
continue ;
Point3d ptLineTria1, ptLineTria2 ;
// Studio dell'intersezione della retta con il triangolo corrente
int nIntType = IntersLineTria( ptP, vtD, 1.5 * dU2, trTria, ptLineTria1, ptLineTria2) ;
// Se non ci sono intersezioni passo al prossimo triangolo
if ( nIntType == ILTT_NO)
continue ;
// se altrimenti c'è una sola intersezione
else if ( nIntType == ILTT_VERT || nIntType == ILTT_EDGE || nIntType == ILTT_IN) {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
vIntersInfo.emplace_back( nIntType, ( ptLineTria1 - ptP) * vtD,
nNumVox, nB, ptLineTria1, trTria) ;
}
// altrimenti ci sono due intersezioni
else {
int nNumVox ;
GetVoxNFromIJK( nCurVoxIJK[0], nCurVoxIJK[1], nCurVoxIJK[2], nNumVox) ;
double dP1 = ( ptLineTria1 - ptP) * vtD ;
double dP2 = ( ptLineTria2 - ptP) * vtD ;
vIntersInfo.emplace_back( nIntType, ( dP1 < dP2 ? dP1 : dP2), ( dP1 < dP2 ? dP2 : dP1),
nNumVox, nB, ptLineTria1, ptLineTria2, trTria) ;
}
}
}
}
}
// Ordino le intersezioni in base al parametro distanza con segno da ptP
sort( vIntersInfo.begin(), vIntersInfo.end(),
[]( const IntLineZmapInfo& a, const IntLineZmapInfo& b)
{ double dFP = (( a.nILTT == ILTT_SEGM || a.nILTT == ILTT_SEGM_ON_EDGE) ? 0.5 * ( a.dU + a.dU2) : a.dU) ;
double dLP = (( b.nILTT == ILTT_SEGM || b.nILTT == ILTT_SEGM_ON_EDGE) ? 0.5 * ( b.dU + b.dU2) : b.dU) ;
return ( dLP > dFP) ; }) ;
return true ;
}
//----------------------------------------------------------------------------
// Il piano è espresso nel sistema locale, la funzione lo esprime nel sistema Zmap.
// I loop della flat region ottenuta dall'intersezione vengono salvati nello
@@ -1513,45 +1522,115 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
// Verifico validità parametri
if ( ! plPlane.IsValid())
return false ;
// Porto il piano nel sistema Zmap
Plane3d plPlaneL = plPlane ;
plPlaneL.ToLoc( m_MapFrame) ;
// Vettore del piano
Vector3d vtNL = plPlaneL.GetVersN() ;
Plane3d plPlaneLoc = plPlane ;
plPlaneLoc.ToLoc( m_MapFrame) ;
// Se il piano non interseca il bounding box del solido, abbiamo finito
if ( ! TestIntersPlaneZmapBBox( plPlaneL))
// Se non c'è intersezione fra piano e bounding-box del solido, ho finito.
if ( ! TestIntersPlaneZmapBBox( plPlaneLoc))
return true ;
// Cerco la mappa con i dexel più perpendicolari al piano e valuto
// se il versore del piano è equiverso o controverso ai dexel.
int nGrid = 0 ;
int nSign = ( vtNL.z > 0 ? 1 : - 1) ;
if ( abs( vtNL.x) > abs( vtNL.y) && abs( vtNL.x) > abs( vtNL.z)) {
nGrid = 1 ;
nSign = ( vtNL.x > 0 ? 1 : - 1) ;
}
else if ( abs( vtNL.y) > abs( vtNL.x) && abs( vtNL.y) > abs( vtNL.z)) {
nGrid = 2 ;
nSign = ( vtNL.y > 0 ? 1 : - 1) ;
}
// Ciclo sulle celle
// Lancio eventuale aggiornamento pendente della grafica
if ( m_nMapNum == 1)
UpdateSingleMapGraphics() ;
else
UpdateTripleMapGraphics() ;
// Vettore di segmenti
vector<CurveLine> vLine ;
for ( int ni = - 1 ; ni < int( m_nNx[nGrid]) ; ++ ni) {
for ( int nj = - 1 ; nj < int( m_nNy[nGrid]) ; ++ nj) {
ProcessCell( nGrid, ni, nj, plPlaneL, vLine) ;
// Ciclo sui blocchi
for ( int nB = 0 ; nB < m_nNumBlock ; ++ nB) {
// Determino indici IJK del blocco; Se non trovo il blocco, errore
int nBlockIJK[3] ;
if ( ! GetBlockIJKFromN( nB, nBlockIJK))
return false ;
// Costruisco il bounding-bx del blocco; se non è possiblie, errore
BBox3d b3BlockBox ;
if ( ! GetBlockBox( nBlockIJK, b3BlockBox))
return false ;
// Se c'è intersezione valuto tutti i voxel interni
if ( TestIntersPlaneBox( b3BlockBox, plPlaneLoc)) {
// Ciclo sui voxel del blocco.
// Triangoli smooth
for ( int nV = 0 ; nV < int( m_BlockSmoothTria[nB].size()) ; ++ nV) {
// Box del voxel
BBox3d b3Vox ;
GetVoxelBox( m_BlockSmoothTria[nB][nV].i, m_BlockSmoothTria[nB][nV].j, m_BlockSmoothTria[nB][nV].k, b3Vox) ;
// Se non c'è intersezione col voxel, passo al successivo.
if ( ! TestIntersPlaneBox(b3Vox, plPlaneLoc))
continue ;
for ( int nT = 0 ; nT < int( m_BlockSmoothTria[nB][nV].vTria.size()) ; ++ nT) {
Triangle3d trTria = m_BlockSmoothTria[nB][nV].vTria[nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
// Costruisco il tratto di curva
CurveLine cvLine ;
if ( cvLine.Set( ptSt, ptEn))
vLine.emplace_back( cvLine) ;
}
}
}
// Triangoli sharp interni al blocco
for ( int nV = 0 ; nV < int( m_BlockSharpTria[nB].size()) ; ++ nV) {
// Box del voxel
BBox3d b3Vox ;
GetVoxelBox( m_BlockSharpTria[nB][nV].i, m_BlockSharpTria[nB][nV].j, m_BlockSharpTria[nB][nV].k, b3Vox) ;
// Se non c'è intersezione col voxel, passo al successivo.
// Ciclo sulle componenti connesse
for ( int nC = 0 ; nC < int( m_BlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
for ( int nT = 0 ; nT < int( m_BlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
Triangle3d trTria = m_BlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria(plPlane, trTria, ptSt, ptEn) ;
if (nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
// Costruisco il tratto di curva
CurveLine cvLine ;
if ( cvLine.Set(ptSt, ptEn))
vLine.emplace_back( cvLine) ;
}
}
}
}
// Triangoli grandi del blocco
for ( int nT = 0 ; nT < int( m_BlockBigTria[nB].size()) ; ++ nT) {
Triangle3d trTria = m_BlockBigTria[nB][nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria(plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
// Costruisco il tratto di curva
CurveLine cvLine ;
if ( cvLine.Set(ptSt, ptEn))
vLine.emplace_back( cvLine) ;
}
}
}
// In ogni caso valuto i triangoli sharp fra blocchi
for ( int nV = 0 ; nV < int( m_InterBlockSharpTria[nB].size()) ; ++ nV) {
// Ciclo sulle componenti connesse
for ( int nC = 0 ; nC < int( m_InterBlockSharpTria[nB][nV].vCompoTria.size()) ; ++ nC) {
for ( int nT = 0 ; nT < int( m_InterBlockSharpTria[nB][nV].vCompoTria[nC].size()) ; ++ nT) {
Triangle3d trTria = m_InterBlockSharpTria[nB][nV].vCompoTria[nC][nT] ;
Point3d ptSt, ptEn ;
int nIntersType = IntersPlaneTria( plPlane, trTria, ptSt, ptEn) ;
if ( nIntersType == IPTT_EDGE || nIntersType == IPTT_YES) {
// Costruisco il tratto di curva
CurveLine cvLine ;
if ( cvLine.Set(ptSt, ptEn))
vLine.emplace_back( cvLine) ;
}
}
}
}
}
// Creo i loop
ChainCurves LoopCreator ;
LoopCreator.Init( false, EPS_SMALL, int( vLine.size())) ;
// Carico le curve per concatenarle
// Carico le curve per concatenarle
for ( int nCv = 0 ; nCv < int( vLine.size()) ; ++ nCv) {
Point3d ptSt = vLine[nCv].GetStart() ;
Point3d ptEn = vLine[nCv].GetEnd() ;
Vector3d vtDir ; vLine[nCv].GetStartDir( vtDir) ;
Point3d ptEn = vLine[nCv].GetEnd() ;
Vector3d vtDir; vLine[nCv].GetStartDir(vtDir) ;
LoopCreator.AddCurve( nCv + 1, ptSt, vtDir, ptEn, vtDir) ;
}
// Recupero i concatenamenti
@@ -1563,266 +1642,15 @@ VolZmap::GetPlaneIntersection( const Plane3d& plPlane, ICURVEPOVECTOR& vpLoop) c
return false ;
for ( auto i : vIds) {
// Aggiungo la linea alla curva composta.
if ( ! pLoop->AddCurve( vLine[i-1], true, EPS_SMALL))
if ( ! pLoop->AddCurve( vLine[i - 1], true, 10 * EPS_SMALL))
return false ;
}
pLoop->SetExtrusion( vtNL) ;
pLoop->ToGlob( m_MapFrame) ;
// Se normali controverse, devo invertire il verso del loop.
if ( nSign < 0)
pLoop->Invert() ;
// eseguo approssimazione
PolyLine PL ;
if ( ! pLoop->ApproxWithLines( m_dStep, ANG_TOL_STD_DEG, ICurve::APL_RIGHT, PL) ||
! pLoop->Clear() || ! pLoop->FromPolyLine( PL))
return false ;
pLoop->MergeCurves( m_dStep, ANG_TOL_STD_DEG) ;
// Inserisco la curva composita nella raccolta da ritornare
vpLoop.emplace_back( Release( pLoop)) ;
}
return true ;
}
//----------------------------------------------------------------------------
// Data una cella, identificata dal numero della sua griglia e dai suoi indici i,j
// all'interno della griglia, genera gli eventuali segmenti che costituiscono la curva
// corrispondente alla frontiera della regione di piano interna la solido.
// Se la griglia o la cella non è valida, la funzione restituisce false,
// altrimenti valuta la tipologia della cella e crea gli eventuali segmenti.
// Se il processo va a buon fine la funzione restituisce true.
bool
VolZmap::ProcessCell( int nGrid, int nCellI, int nCellJ, const Plane3d& plPlane, vector<CurveLine>& vLine) const
{
// Se la griglia non esiste vi è un errore
if ( nGrid < 0 || nGrid > 2)
return false ;
// Se la cella non esiste vi è un errore
if ( nCellI < - 1 || nCellI >= int( m_nNx[nGrid]) ||
nCellJ < - 1 || nCellJ >= int( m_nNy[nGrid]))
return false ;
// Determino la configurazione della cella
int nIndex = CalcIndexForPlaneCells( plPlane, nGrid, nCellI, nCellJ) ;
// Tabella segmenti
static int nLineTable[16][5] = {
{ -1, -1, -1, -1, -1},
{ 0, 3, -1, -1, -1},
{ 1, 0, -1, -1, -1},
{ 1, 3, -1, -1, -1},
{ 2, 1, -1, -1, -1},
{ 0, 1, 2, 3, -1},
{ 2, 0, -1, -1, -1},
{ 2, 3, -1, -1, -1},
{ 3, 2, -1, -1, -1},
{ 0, 2, -1, -1, -1},
{ 1, 2, 3, 0, -1},
{ 1, 2, -1, -1, -1},
{ 3, 1, -1, -1, -1},
{ 0, 1, -1, -1, -1},
{ 3, 0, -1, -1, -1},
{ -1, -1, -1, -1, -1}
} ;
// Tabella dei punti medi dei segmenti: le righe rappresentano
// il numero di segmento (0, 1, 2, 3) le colonne rappresentano
// i e j.
static double dDeltaIJ[4][2] = {
{ 0.5, 0},
{ 1, 0.5},
{ 0.5, 1},
{ 0, 0.5}
} ;
// Se la cella è di frontiera costruisco i segmenti della curva
if ( nIndex != 0 && nIndex != 15) {
// Ciclo su tutti gli spigoli della cella che vengono attraversati dalla curva.
for ( int nEdge = 0 ; nLineTable[nIndex][nEdge] != -1 ; nEdge += 2) {
int nStEdge = nLineTable[nIndex][nEdge] ;
int nEnEdge = nLineTable[nIndex][nEdge + 1] ;
double nStDeltaI = dDeltaIJ[nStEdge][0] ;
double nStDeltaJ = dDeltaIJ[nStEdge][1] ;
double nEnDeltaI = dDeltaIJ[nEnEdge][0] ;
double nEnDeltaJ = dDeltaIJ[nEnEdge][1] ;
if ( nGrid == 0) {
// Punti sulla griglia
Point3d ptGrSt( ( nCellI + nStDeltaI + 0.5) * m_dStep, ( nCellJ + nStDeltaJ + 0.5) * m_dStep, 0) ;
Point3d ptGrEn( ( nCellI + nEnDeltaI + 0.5) * m_dStep, ( nCellJ + nEnDeltaJ + 0.5) * m_dStep, 0) ;
// Corrispondenti punti sul piano
Point3d ptSt, ptEn ;
if ( IntersLinePlane( ptGrSt, Z_AX, 10, plPlane, ptSt, false) &&
IntersLinePlane( ptGrEn, Z_AX, 10, plPlane, ptEn, false)) {
// Costruisco il tratto di curva
CurveLine cvLine ;
cvLine.Set( ptSt, ptEn) ;
vLine.emplace_back( cvLine) ;
}
}
else if ( nGrid == 1) {
// Punti sulla griglia
Point3d ptGrSt( 0, ( nCellI + nStDeltaI + 0.5) * m_dStep, ( nCellJ + nStDeltaJ + 0.5) * m_dStep) ;
Point3d ptGrEn( 0, ( nCellI + nEnDeltaI + 0.5) * m_dStep, ( nCellJ + nEnDeltaJ + 0.5) * m_dStep) ;
// Corrispondenti punti sul piano
Point3d ptSt, ptEn ;
if ( IntersLinePlane( ptGrSt, X_AX, 10, plPlane, ptSt, false) &&
IntersLinePlane( ptGrEn, X_AX, 10, plPlane, ptEn, false)) {
// Costruisco il tratto di curva
CurveLine cvLine ;
cvLine.Set( ptSt, ptEn) ;
vLine.emplace_back( cvLine) ;
}
}
else {
// Punti sulla griglia
Point3d ptGrSt( ( nCellJ + nStDeltaJ + 0.5) * m_dStep, 0, ( nCellI + nStDeltaI + 0.5) * m_dStep) ;
Point3d ptGrEn( ( nCellJ + nEnDeltaJ + 0.5) * m_dStep, 0, ( nCellI + nEnDeltaI + 0.5) * m_dStep) ;
// Corrispondenti punti sul piano
Point3d ptSt, ptEn ;
if ( IntersLinePlane( ptGrSt, Y_AX, 10, plPlane, ptSt, false) &&
IntersLinePlane( ptGrEn, Y_AX, 10, plPlane, ptEn, false)) {
// Costruisco il tratto di curva
CurveLine cvLine ;
cvLine.Set( ptSt, ptEn) ;
vLine.emplace_back( cvLine) ;
}
}
}
pLoop->SetExtrusion( plPlane.GetVersN()) ;
pLoop->MergeCurves( 10 * EPS_SMALL, ANG_TOL_STD_DEG) ;
// Inserisco la curva composita nella raccolta da ritornare
vpLoop.emplace_back( Release( pLoop)) ;
}
return true ;
}
//----------------------------------------------------------------------------
// Dato un dexel, identificato dal numero della sua griglia e dai suoi indici,
// determina se un suo intervallo attraversa il piano dato.
// Il numero di griglia e gli indici del dexel devono essere validi, se
// non lo sono, la funzione restituisce false, altrimenti cerca un
// tratto di dexel che intersechi il piano, se lo trova restituisce true,
// false altrimenti.
bool
VolZmap::InOut( const Plane3d& plPlane, int nGrid, int nI, int nJ) const
{
// Se la griglia non esiste, vi è un errore.
if ( nGrid < 0 || nGrid > 2)
return false ;
// Se gli indici sono di frontiera per lo
// Zmap o non esistono, non sono interni.
if ( nI <= - 1 || nI >= int( m_nNx[nGrid]) ||
nJ <= - 1 || nJ >= int( m_nNy[nGrid]))
return false ;
// Numero del dexel
int nDex = nJ * m_nNx[nGrid] + nI ;
// Ciclo sui segmenti del dexel
bool bNotFound = true ;
for ( int nK = 0 ; nK < int( m_Values[nGrid][nDex].size()) ; ++ nK) {
if ( nGrid == 0) {
// Punti estremi del segmento
Point3d ptSt( ( nI + 0.5) * m_dStep, ( nJ + 0.5) * m_dStep, m_Values[nGrid][nDex][nK].dMin) ;
Point3d ptEn( ( nI + 0.5) * m_dStep, ( nJ + 0.5) * m_dStep, m_Values[nGrid][nDex][nK].dMax) ;
// Se il segmento interseca il piano abbiamo finito
Point3d ptInt ;
if ( IntersLinePlane( ptSt, ptEn, plPlane, ptInt))
return true ;
}
else if ( nGrid == 1) {
// Punti estremi del segmento
Point3d ptSt( m_Values[nGrid][nDex][nK].dMin, ( nI + 0.5) * m_dStep, ( nJ + 0.5) * m_dStep) ;
Point3d ptEn( m_Values[nGrid][nDex][nK].dMax, ( nI + 0.5) * m_dStep, ( nJ + 0.5) * m_dStep) ;
// Se il segmento interseca il piano abbiamo finito
Point3d ptInt ;
if ( IntersLinePlane( ptSt, ptEn, plPlane, ptInt))
return true ;
}
else {
// Punti estremi del segmento
Point3d ptSt( ( nJ + 0.5) * m_dStep, m_Values[nGrid][nDex][nK].dMin, ( nI + 0.5) * m_dStep) ;
Point3d ptEn( ( nJ + 0.5) * m_dStep, m_Values[nGrid][nDex][nK].dMax, ( nI + 0.5) * m_dStep) ;
// Se il segmento interseca il piano abbiamo finito
Point3d ptInt ;
if ( IntersLinePlane( ptSt, ptEn, plPlane, ptInt))
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
int
VolZmap::CalcIndexForPlaneCells( const Plane3d& plPlane, int nGrid, int nCellI, int nCellJ) const
{
int nIndex = 0 ;
if ( InOut( plPlane, nGrid, nCellI, nCellJ))
nIndex |= ( 1 << 0) ;
if ( InOut( plPlane, nGrid, nCellI + 1, nCellJ))
nIndex |= ( 1 << 1) ;
if ( InOut( plPlane, nGrid, nCellI + 1, nCellJ + 1))
nIndex |= ( 1 << 2) ;
if ( InOut( plPlane, nGrid, nCellI, nCellJ + 1))
nIndex |= ( 1 << 3) ;
return nIndex ;
}
//----------------------------------------------------------------------------
// dZ è una quota relativa alla mappa nGrid, se il dexel nDex esiste e
// dZ è interna a un suo intervallo restituisce true, false altrimenti.
bool
VolZmap::IsZInsideInterval( int nGrid, int nDex, double dZ) const
{
// Se la griglia non esiste vi è un errore.
if ( nGrid < 0 || nGrid > 2)
return false ;
// Se il dexel non esiste vi è un errore.
if ( nDex < 0 && nDex > int( m_Values[nGrid].size() - 1))
return false ;
// Valuto se dZ è interna a un intervallo.
for ( int nk = 0 ; nk < int( m_Values[nGrid][nDex].size()) ; ++ nk) {
double dZ1 = m_Values[nGrid][nDex][nk].dMin ;
double dZ2 = m_Values[nGrid][nDex][nk].dMax ;
// Se troviamo dZ in un intervallo abbiamo finito.
if ( dZ > dZ1 && dZ < dZ2)
return true ;
}
// dZ non sta in un intervallo.
return false ;
}
//----------------------------------------------------------------------------
// Box e piano devono essere nello stesso riferimento. Il box deve essere axis aligned.
bool
TestIntersPlaneBox( const BBox3d& b3Box, const Plane3d& plPlane)
{
// Calcolo le distanze con segno dei punti dal piano
Point3d ptE0 = b3Box.GetMin() ;
double dDist0 = DistPointPlane( ptE0, plPlane) ;
Point3d ptE1( b3Box.GetMax().x, b3Box.GetMin().y, b3Box.GetMin().z) ;
double dDist1 = DistPointPlane( ptE1, plPlane) ;
Point3d ptE2( b3Box.GetMax().x, b3Box.GetMax().y, b3Box.GetMin().z) ;
double dDist2 = DistPointPlane( ptE2, plPlane) ;
Point3d ptE3( b3Box.GetMin().x, b3Box.GetMax().y, b3Box.GetMin().z) ;
double dDist3 = DistPointPlane( ptE3, plPlane) ;
Point3d ptE4( b3Box.GetMin().x, b3Box.GetMin().y, b3Box.GetMax().z) ;
double dDist4 = DistPointPlane( ptE4, plPlane) ;
Point3d ptE5( b3Box.GetMax().x, b3Box.GetMin().y, b3Box.GetMax().z) ;
double dDist5 = DistPointPlane( ptE5, plPlane) ;
Point3d ptE6 = b3Box.GetMax() ;
double dDist6 = DistPointPlane( ptE6, plPlane) ;
Point3d ptE7( b3Box.GetMin().x, b3Box.GetMax().y, b3Box.GetMax().z) ;
double dDist7 = DistPointPlane( ptE7, plPlane) ;
// Distanze tutte positive
if ( dDist0 > EPS_SMALL && dDist1 > EPS_SMALL && dDist2 > EPS_SMALL && dDist3 > EPS_SMALL &&
dDist4 > EPS_SMALL && dDist5 > EPS_SMALL && dDist6 > EPS_SMALL && dDist7 > EPS_SMALL)
return false ;
// Distanze tutte negative
if ( dDist0 < - EPS_SMALL && dDist1 < - EPS_SMALL && dDist2 < - EPS_SMALL && dDist3 < - EPS_SMALL &&
dDist4 < - EPS_SMALL && dDist5 < - EPS_SMALL && dDist6 < - EPS_SMALL && dDist7 < - EPS_SMALL)
return false ;
// Il piano interseca il box
return true ;
}
VolZmapGraphics.cpp
+149 -55
View File
@@ -1971,7 +1971,7 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
Vector3d vtNlm = ( CompoVert[nComp][l].ptPApp - ptSol) ^ ( CompoVert[nComp][m].ptPApp - ptSol) ;
vtNlm.Normalize() ;
double dDotl = vtNlm * CompoVert[nComp][l].vtVec ;
double dDotm = vtNlm * CompoVert[nComp][m].vtVec;
double dDotm = vtNlm * CompoVert[nComp][m].vtVec ;
if ( dDotl < - 0.85 || dDotm < - 0.85) {
bOverTurning = true ;
break ;
@@ -2000,6 +2000,44 @@ VolZmap::ExtMarchingCubes( int nBlock, VoxelContainer& vVox) const
}
}
// Gestione casi speciali: tutti i vettori quasi equiversi tranne uno
if ( bExtConfirmed && ( nVertComp[nComp] == 4 || nVertComp[nComp] == 5)) {
int nParNum = 0 ;
for ( int m = 0 ; m < nVertComp[nComp] - 1 ; ++ m) {
for ( int l = m + 1 ; l < nVertComp[nComp] ; ++ l) {
if ( CompoVert[nComp][m].vtVec * CompoVert[nComp][l].vtVec > 0.9) {
++ nParNum ;
}
}
}
if ( nParNum == ( nVertComp[nComp] - 1) * ( nVertComp[nComp] - 2) / 2) {
int nNotParIndex = - 1 ;
for ( int m = 0 ; m < nVertComp[nComp] ; ++ m) {
int nNumDiff = 0 ;
for ( int l = 0 ; l < nVertComp[nComp] ; ++ l) {
if ( CompoVert[nComp][m].vtVec * CompoVert[nComp][l].vtVec <= 0.9) {
++ nNumDiff ;
}
}
if ( nNumDiff == nVertComp[nComp] - 1) {
nNotParIndex = m ;
break ;
}
}
int nPrevL = nNotParIndex > 0 ? nNotParIndex - 1 : nVertComp[nComp] - 1 ;
int nNextL = nNotParIndex < nVertComp[nComp] - 1 ? nNotParIndex + 1 : 0 ;
Vector3d vtPrevN = ( CompoVert[nComp][nNotParIndex].ptPApp - ptSol) ^ ( CompoVert[nComp][nPrevL].ptPApp - ptSol) ;
Vector3d vtNextN = ( CompoVert[nComp][nNextL].ptPApp - ptSol) ^ ( CompoVert[nComp][nNotParIndex].ptPApp - ptSol) ;
vtPrevN.Normalize() ;
vtNextN.Normalize() ;
if ( nNotParIndex >= 0 &&
CompoVert[nComp][nNotParIndex].vtVec * vtPrevN < - EPS_SMALL &&
CompoVert[nComp][nNotParIndex].vtVec * vtNextN < - EPS_SMALL) {
bExtConfirmed = false ;
}
}
}
// ExtMC confermato
if ( bExtConfirmed) {
int tOldCompo = VoxConf.nNumComp ;
@@ -3450,9 +3488,9 @@ VolZmap::IsValidVoxel( int nI, int nJ, int nK) const
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Verifico la validità del voxel
return ( nI >= - 1 && nI < nVoxNumX - 1 &&
nJ >= - 1 && nJ < nVoxNumY - 1 &&
nK >= - 1 && nK < nVoxNumZ - 1 ) ;
return ( nI >= -1 && nI <= nVoxNumX - 2 &&
nJ >= -1 && nJ <= nVoxNumY - 2 &&
nK >= -1 && nK <= nVoxNumZ - 2) ;
}
//----------------------------------------------------------------------------
@@ -3474,9 +3512,9 @@ VolZmap::GetVoxIJKFromN( int nN, int& nI, int& nJ, int& nK) const
nK = ( nN / ( nVoxNumX * nVoxNumY)) - 1 ;
// Controllo la sensatezza del risultato ottenuto
return ( nI >= - 1 && nI < nVoxNumX - 1 &&
nJ >= - 1 && nJ < nVoxNumY - 1 &&
nK >= - 1 && nK < nVoxNumZ - 1 ) ;
return ( nI >= -1 && nI <= nVoxNumX - 2 &&
nJ >= -1 && nJ <= nVoxNumY - 2 &&
nK >= -1 && nK <= nVoxNumZ - 2) ;
}
//----------------------------------------------------------------------------
@@ -3489,9 +3527,9 @@ VolZmap::GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Controllo la validità del voxel
if ( nI <= - 2 || nI >= nVoxNumX - 1 ||
nJ <= - 2 || nJ >= nVoxNumY - 1 ||
nK <= - 2 || nK >= nVoxNumZ - 1 )
if ( nI < -1 || nI > nVoxNumX - 2 ||
nJ < -1 || nJ > nVoxNumY - 2 ||
nK < -1 || nK > nVoxNumZ - 2)
return false ;
// Calcolo il numero di Voxel
@@ -3501,6 +3539,32 @@ VolZmap::GetVoxNFromIJK( int nI, int nJ, int nK, int& nN) const
return ( nN >= 0 && nN < nVoxNumX * nVoxNumY * nVoxNumZ) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetVoxelBox( int nI, int nJ, int nK, BBox3d& b3VoxBox) const
{
// Calcolo il numero di voxel lungo X,Y e Z
int nVoxNumX = int( m_nNx[0] / N_DEXVOXRATIO + ( m_nNx[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Controllo la validità del voxel
if ( nI < -1 || nI > nVoxNumX - 2 ||
nJ < -1 || nJ > nVoxNumY - 2 ||
nK < -1 || nK > nVoxNumZ - 2)
return false ;
// Punti della diagonale del voxel
Point3d ptCubeInf( ( nI * N_DEXVOXRATIO + 0.5) * m_dStep,
( nJ * N_DEXVOXRATIO + 0.5) * m_dStep,
( nK * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptCubeSup( ( ( nI + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nJ + 1) * N_DEXVOXRATIO + 0.5) * m_dStep,
( ( nK + 1) * N_DEXVOXRATIO + 0.5) * m_dStep) ;
b3VoxBox.Set( ptCubeInf, ptCubeSup) ;
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetBlockIJKFromN( int nBlock, int nIJK[]) const
@@ -3538,9 +3602,9 @@ bool
VolZmap::GetBlockLimitsIJK( const int nIJK[], int nLimits[]) const
{
// Controllo sulla validità degli indici i, j, k del blocco
if ( nIJK[0] < 0 || nIJK[0] >= int( m_nFracLin[0]) ||
nIJK[1] < 0 || nIJK[1] >= int( m_nFracLin[1]) ||
nIJK[2] < 0 || nIJK[2] >= int( m_nFracLin[2]))
if ( nIJK[0] < 0 || nIJK[0] >= m_nFracLin[0] ||
nIJK[1] < 0 || nIJK[1] >= m_nFracLin[1] ||
nIJK[2] < 0 || nIJK[2] >= m_nFracLin[2])
return false ;
// Calcolo il numero di voxel lungo X,Y e Z
@@ -3549,23 +3613,42 @@ VolZmap::GetBlockLimitsIJK( const int nIJK[], int nLimits[]) const
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Calcolo limiti per l'indice i
nLimits[0] = ( nIJK[0] == 0 ? - 1 : nIJK[0] * int( m_nVoxNumPerBlock)) ;
nLimits[1] = ( nIJK[0] + 1 == int( m_nFracLin[0]) ?
nVoxNumX - 1 : ( nIJK[0] + 1) * int( m_nVoxNumPerBlock)) ;
nLimits[0] = ( nIJK[0] == 0 ? - 1 : nIJK[0] * m_nVoxNumPerBlock) ;
nLimits[1] = ( nIJK[0] + 1 == m_nFracLin[0] ?
nVoxNumX - 1 : ( nIJK[0] + 1) * m_nVoxNumPerBlock) ;
// Calcolo limiti per l'indice j
nLimits[2] = ( nIJK[1] == 0 ? - 1 : nIJK[1] * int( m_nVoxNumPerBlock)) ;
nLimits[3] = ( nIJK[1] + 1 == int( m_nFracLin[1]) ?
nVoxNumY - 1 : ( nIJK[1] + 1) * int( m_nVoxNumPerBlock)) ;
nLimits[2] = ( nIJK[1] == 0 ? - 1 : nIJK[1] * m_nVoxNumPerBlock) ;
nLimits[3] = ( nIJK[1] + 1 == m_nFracLin[1] ?
nVoxNumY - 1 : ( nIJK[1] + 1) * m_nVoxNumPerBlock) ;
// Calcolo limiti per l'indice k
nLimits[4] = ( nIJK[2] == 0 ? - 1 : nIJK[2] * int( m_nVoxNumPerBlock)) ;
nLimits[5] = ( nIJK[2] + 1 == int( m_nFracLin[2]) ?
nVoxNumZ - 1 : ( nIJK[2] + 1) * int( m_nVoxNumPerBlock)) ;
nLimits[4] = ( nIJK[2] == 0 ? - 1 : nIJK[2] * m_nVoxNumPerBlock) ;
nLimits[5] = ( nIJK[2] + 1 == m_nFracLin[2] ?
nVoxNumZ - 1 : ( nIJK[2] + 1) * m_nVoxNumPerBlock) ;
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetBlockBox( const int nIJK[], BBox3d& b3VoxBox) const
{
// Calcolo limiti sugli indici del blocco; se il blocco non è valido, errore
int nLimits[6] ;
if ( ! GetBlockLimitsIJK( nIJK, nLimits))
return false ;
// Costruisco il bounding-bx del blocco
Point3d ptMinDiag( ( nLimits[0] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[2] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[4] * N_DEXVOXRATIO + 0.5) * m_dStep) ;
Point3d ptMaxDiag( ( nLimits[1] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[3] * N_DEXVOXRATIO + 0.5) * m_dStep,
( nLimits[5] * N_DEXVOXRATIO + 0.5) * m_dStep) ;
b3VoxBox.Set( ptMinDiag, ptMaxDiag) ;
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, double dPrec) const
@@ -3575,9 +3658,9 @@ VolZmap::IsPointInsideVoxelApprox( int nI, int nJ, int nK, const Point3d& ptP, d
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Controllo sulla validità del voxel
if ( nI <= - 2 || nI >= nVoxNumX - 1 ||
nJ <= - 2 || nJ >= nVoxNumY - 1 ||
nK <= - 2 || nK >= nVoxNumZ - 1 )
if ( nI < -1 || nI > nVoxNumX - 2 ||
nJ < -1 || nJ > nVoxNumY - 2 ||
nK < -1 || nK > nVoxNumZ - 2)
return false ;
// Se la tolleranza è minore di EPS_SMALL, la considero nulla
if ( dPrec < EPS_ZERO)
@@ -3606,9 +3689,9 @@ VolZmap::GetPointVoxel( const Point3d& ptP, int& nVoxI, int& nVoxJ, int& nVoxK)
nVoxJ = int( floor( ( ptP.y - 0.5 * m_dStep) / ( m_dStep * N_DEXVOXRATIO))) ;
nVoxK = int( floor( ( ptP.z - 0.5 * m_dStep) / ( m_dStep * N_DEXVOXRATIO))) ;
// Controllo la validità del voxel
return ( nVoxI >= - 1 && nVoxI < nVoxNumX - 1) &&
( nVoxJ >= - 1 && nVoxJ < nVoxNumY - 1) &&
( nVoxK >= - 1 && nVoxK < nVoxNumZ - 1) ;
return ( nVoxI >= - 1 && nVoxI <= nVoxNumX - 2 &&
nVoxJ >= - 1 && nVoxJ <= nVoxNumY - 2 &&
nVoxK >= - 1 && nVoxK <= nVoxNumZ - 2) ;
}
//----------------------------------------------------------------------------
@@ -3620,9 +3703,9 @@ VolZmap::GetVoxelBlockIJK( const int nVoxIJK[], int nBlockIJK[]) const
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Controllo sull'ammissibilità del voxel
if ( nVoxIJK[0] <= - 2 || nVoxIJK[0] >= nVoxNumX - 1 ||
nVoxIJK[1] <= - 2 || nVoxIJK[1] >= nVoxNumY - 1 ||
nVoxIJK[2] <= - 2 || nVoxIJK[2] >= nVoxNumZ - 1 )
if ( nVoxIJK[0] < -1 || nVoxIJK[0] > nVoxNumX - 2 ||
nVoxIJK[1] < -1 || nVoxIJK[1] > nVoxNumY - 2 ||
nVoxIJK[2] < -1 || nVoxIJK[2] > nVoxNumZ - 2)
return false ;
// Divisioni intere
int nIntRatio0 = nVoxIJK[0] / m_nVoxNumPerBlock ;
@@ -3636,14 +3719,25 @@ VolZmap::GetVoxelBlockIJK( const int nVoxIJK[], int nBlockIJK[]) const
return true ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetVoxelBlockN( int nVox, int& nBlock) const
{
int nVoxIJK[3] ;
int nBlockIJK[3] ;
return ( GetVoxIJKFromN( nVox, nVoxIJK[0], nVoxIJK[1], nVoxIJK[2]) &&
GetVoxelBlockIJK( nVoxIJK, nBlockIJK) &&
GetBlockNFromIJK( nBlockIJK, nBlock)) ;
}
//----------------------------------------------------------------------------
bool
VolZmap::GetAdjBlockToBlock( int nBlockN, int nDeltaI, int nDeltaJ, int nDeltaK, int& nAdjBlockN) const
{
// Test sulla validità degli incrementi su i,j,k
if ( nDeltaI < - 1 || nDeltaI > 1 ||
nDeltaJ < - 1 || nDeltaJ > 1 ||
nDeltaK < - 1 || nDeltaK > 1)
if ( nDeltaI < -1 || nDeltaI > 1 ||
nDeltaJ < -1 || nDeltaJ > 1 ||
nDeltaK < -1 || nDeltaK > 1)
return false ;
// Determino blocco adiacente
@@ -3666,18 +3760,18 @@ VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], bool bType)
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Test sulla validità dei limiti
if ( nLimits[0] < - 1 || nLimits[0] > nVoxNumX - 1 ||
nLimits[1] < - 1 || nLimits[1] > nVoxNumX - 1 ||
nLimits[2] < - 1 || nLimits[2] > nVoxNumY - 1 ||
nLimits[3] < - 1 || nLimits[3] > nVoxNumY - 1 ||
nLimits[4] < - 1 || nLimits[4] > nVoxNumZ - 1 ||
nLimits[5] < - 1 || nLimits[5] > nVoxNumZ - 1 )
if ( nLimits[0] < -1 || nLimits[0] > nVoxNumX - 1 ||
nLimits[1] < -1 || nLimits[1] > nVoxNumX - 1 ||
nLimits[2] < -1 || nLimits[2] > nVoxNumY - 1 ||
nLimits[3] < -1 || nLimits[3] > nVoxNumY - 1 ||
nLimits[4] < -1 || nLimits[4] > nVoxNumZ - 1 ||
nLimits[5] < -1 || nLimits[5] > nVoxNumZ - 1 )
return false ;
// Controllo sull'ammissibilità del voxel
if ( nIJK[0] <= -2 || nIJK[0] > nVoxNumX - 2 ||
nIJK[1] <= -2 || nIJK[1] > nVoxNumY - 2 ||
nIJK[2] <= -2 || nIJK[2] > nVoxNumZ - 2)
if ( nIJK[0] < -1 || nIJK[0] > nVoxNumX - 2 ||
nIJK[1] < -1 || nIJK[1] > nVoxNumY - 2 ||
nIJK[2] < -1 || nIJK[2] > nVoxNumZ - 2)
return false ;
// Se cerchiamo i voxel che sono sulla frontiera del blocco
@@ -3707,9 +3801,9 @@ VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], bool bType)
// Determino (se esiste) il blocco in cui cade il voxel adiacente.
int nAdjBlockIJK[3] ;
if ( GetVoxelBlockIJK( nAdjIJK, nAdjBlockIJK)) {
if ( nAdjBlockIJK[0] > -1 && nAdjBlockIJK[0] < int( m_nFracLin[0]) &&
nAdjBlockIJK[1] > -1 && nAdjBlockIJK[1] < int( m_nFracLin[1]) &&
nAdjBlockIJK[2] > -1 && nAdjBlockIJK[2] < int( m_nFracLin[2]) &&
if ( nAdjBlockIJK[0] > -1 && nAdjBlockIJK[0] < m_nFracLin[0] &&
nAdjBlockIJK[1] > -1 && nAdjBlockIJK[1] < m_nFracLin[1] &&
nAdjBlockIJK[2] > -1 && nAdjBlockIJK[2] < m_nFracLin[2] &&
( nCurrentBlockIJK[0] != nAdjBlockIJK[0] ||
nCurrentBlockIJK[1] != nAdjBlockIJK[1] ||
nCurrentBlockIJK[2] != nAdjBlockIJK[2])) {
@@ -3732,17 +3826,17 @@ VolZmap::IsAVoxelOnBoundary( const int nLimits[], const int nIJK[], int nDeltaIn
int nVoxNumY = int( m_nNy[0] / N_DEXVOXRATIO + ( m_nNy[0] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
int nVoxNumZ = int( m_nNy[1] / N_DEXVOXRATIO + ( m_nNy[1] % N_DEXVOXRATIO == 0 ? 1 : 2)) ;
// Test sulla validità dei limiti
if ( nLimits[0] < - 1 || nLimits[0] > nVoxNumX - 1 ||
nLimits[1] < - 1 || nLimits[1] > nVoxNumX - 1 ||
nLimits[2] < - 1 || nLimits[2] > nVoxNumY - 1 ||
nLimits[3] < - 1 || nLimits[3] > nVoxNumY - 1 ||
nLimits[4] < - 1 || nLimits[4] > nVoxNumZ - 1 ||
nLimits[5] < - 1 || nLimits[5] > nVoxNumZ - 1 )
if ( nLimits[0] < -1 || nLimits[0] > nVoxNumX - 1 ||
nLimits[1] < -1 || nLimits[1] > nVoxNumX - 1 ||
nLimits[2] < -1 || nLimits[2] > nVoxNumY - 1 ||
nLimits[3] < -1 || nLimits[3] > nVoxNumY - 1 ||
nLimits[4] < -1 || nLimits[4] > nVoxNumZ - 1 ||
nLimits[5] < -1 || nLimits[5] > nVoxNumZ - 1 )
return false ;
// Controllo sull'ammissibilità del voxel
if ( nIJK[0] <= -2 || nIJK[0] > nVoxNumX - 2 ||
nIJK[1] <= -2 || nIJK[1] > nVoxNumY - 2 ||
nIJK[2] <= -2 || nIJK[2] > nVoxNumZ - 2)
if ( nIJK[0] < -1 || nIJK[0] > nVoxNumX - 2 ||
nIJK[1] < -1 || nIJK[1] > nVoxNumY - 2 ||
nIJK[2] < -1 || nIJK[2] > nVoxNumZ - 2)
return false ;
nDeltaIndex[0] = 0 ;
nDeltaIndex[1] = 0 ;