Riccardo Elitropi
2806 lines
109 KiB
C++
2806 lines
109 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2016
|
|
//----------------------------------------------------------------------------
|
|
// File : VolZmap.cpp Data : 22.01.15 Versione : 1.6a4
|
|
// Contenuto : Implementazione della classe Volume Zmap (tre griglie)
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 22.01.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "VolZmap.h"
|
|
#include "GeoObjFactory.h"
|
|
#include "GdbGeo.h"
|
|
#include "NgeWriter.h"
|
|
#include "NgeReader.h"
|
|
#include "GeoConst.h"
|
|
#include "/EgtDev/Include/EGkDistPointLine.h"
|
|
#include "/EgtDev/Include/EGkIntersLinePlane.h"
|
|
#include "/EgtDev/Include/EGkUiUnits.h"
|
|
#include "/EgtDev/Include/EGkIntervals.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EgtNumUtils.h"
|
|
#include "/EgtDev/Include/EGkIntersLineSurfTm.h"
|
|
#include <thread>
|
|
#include <future>
|
|
|
|
#define DEBUG_REMOVE_FINS 0
|
|
#if DEBUG_REMOVE_FINS
|
|
#include "/EgtDev/Include/EGkGeoObjSave.h"
|
|
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EGkGeoVector3d.h"
|
|
std::vector<IGeoObj*> VT ;
|
|
std::vector<Color> VC ;
|
|
#endif
|
|
|
|
using namespace std ;
|
|
|
|
#if !defined(_WIN64)
|
|
int VolZmap::m_nDexelNbr = 0 ;
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------
|
|
GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
VolZmap::VolZmap(void)
|
|
: m_nStatus( TO_VERIFY), m_nTempProp{0,0}, m_dTempParam{0.0,0.0}, m_bShowEdges( false),
|
|
m_dStep( 10.0), m_nMapNum( 0), m_nShape( GENERIC), m_nVoxNumPerBlock( N_VOXBLOCK),
|
|
m_nDexVoxRatio( 1), m_nNumBlock( 0), m_nConnectedCompoCount( 0), m_nCurrTool( -1),
|
|
m_dToolLinTol( LIN_TOL_STD), m_dToolAngTolDeg( ANG_TOL_APPROX_DEG)
|
|
{
|
|
for ( int i = 0 ; i < N_MAPS ; ++ i) {
|
|
m_nNx[i] = 0 ;
|
|
m_nNy[i] = 0 ;
|
|
m_nDim[i] = 0 ;
|
|
m_dMinZ[i] = 0 ;
|
|
m_dMaxZ[i] = 0 ;
|
|
m_nFracLin[i] = 0 ;
|
|
}
|
|
m_vTool.resize( 1) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VolZmap::~VolZmap( void)
|
|
{
|
|
// Se versione 32-bit aggiorno il numero di Dexel complessivi rimuovendo il numero dei correnti
|
|
#if !defined(_WIN64)
|
|
int nDexelNbr = 0 ;
|
|
for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
|
|
nDexelNbr += m_nDim[i] ;
|
|
m_nDexelNbr = max( 0, m_nDexelNbr - nDexelNbr) ;
|
|
#endif
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Clear( void)
|
|
{
|
|
m_nStatus = TO_VERIFY ;
|
|
m_nTempProp[0] = 0 ;
|
|
m_nTempProp[1] = 0 ;
|
|
m_dTempParam[0] = 0.0 ;
|
|
m_dTempParam[1] = 0.0 ;
|
|
m_bShowEdges = false ;
|
|
m_dStep = 10.0 ;
|
|
m_nMapNum = 0 ;
|
|
m_nShape = GENERIC ;
|
|
m_nVoxNumPerBlock = N_VOXBLOCK ;
|
|
m_nDexVoxRatio = 1 ;
|
|
m_nNumBlock = 0 ;
|
|
m_nConnectedCompoCount = 0 ;
|
|
m_MapFrame.Reset() ;
|
|
// Se versione 32-bit aggiorno il numero di Dexel complessivi rimuovendo il numero dei correnti
|
|
#if !defined(_WIN64)
|
|
int nDexelNbr = 0 ;
|
|
for ( int i = 0 ; i < ssize( m_nDim) ; ++ i)
|
|
nDexelNbr += m_nDim[i] ;
|
|
m_nDexelNbr = max( 0, m_nDexelNbr - nDexelNbr) ;
|
|
#endif
|
|
for ( int i = 0 ; i < N_MAPS ; ++ i) {
|
|
m_nNx[i] = 0 ;
|
|
m_nNy[i] = 0 ;
|
|
m_nDim[i] = 0 ;
|
|
m_dMinZ[i] = 0 ;
|
|
m_dMaxZ[i] = 0 ;
|
|
m_Values[i].clear() ;
|
|
}
|
|
m_vTool.resize( 1) ;
|
|
m_nCurrTool = 0 ;
|
|
m_dToolLinTol = LIN_TOL_STD ;
|
|
m_dToolAngTolDeg = ANG_TOL_APPROX_DEG ;
|
|
// imposto ri-creazione della grafica
|
|
m_OGrMgr.Clear() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VolZmap*
|
|
VolZmap::Clone( void) const
|
|
{
|
|
// alloco oggetto
|
|
VolZmap* pVzm = new( nothrow) VolZmap ;
|
|
if ( pVzm != nullptr) {
|
|
if ( ! pVzm->CopyFrom( *this)) {
|
|
delete pVzm ;
|
|
return nullptr ;
|
|
}
|
|
}
|
|
|
|
return pVzm ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::CopyFrom( const IGeoObj* pGObjSrc)
|
|
{
|
|
const VolZmap* pVzm = GetBasicVolZmap( pGObjSrc) ;
|
|
if ( pVzm == nullptr)
|
|
return false ;
|
|
return CopyFrom( *pVzm) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::CopyFrom( const VolZmap& vzmSrc)
|
|
{
|
|
if ( &vzmSrc == this)
|
|
return true ;
|
|
|
|
m_nMapNum = vzmSrc.m_nMapNum ;
|
|
m_nShape = vzmSrc.m_nShape ;
|
|
m_nNumBlock = vzmSrc.m_nNumBlock ;
|
|
m_nVoxNumPerBlock = vzmSrc.m_nVoxNumPerBlock ;
|
|
m_nFracLin[0] = vzmSrc.m_nFracLin[0] ;
|
|
m_nFracLin[1] = vzmSrc.m_nFracLin[1] ;
|
|
m_nFracLin[2] = vzmSrc.m_nFracLin[2] ;
|
|
m_nDexVoxRatio = vzmSrc.m_nDexVoxRatio ;
|
|
m_nConnectedCompoCount = vzmSrc.m_nConnectedCompoCount ;
|
|
|
|
m_MapFrame = vzmSrc.m_MapFrame ;
|
|
|
|
for ( int i = 0 ; i < int ( m_nMapNum) ; ++ i) {
|
|
|
|
m_nNx[i] = vzmSrc.m_nNx[i] ;
|
|
m_nNy[i] = vzmSrc.m_nNy[i] ;
|
|
m_nDim[i] = vzmSrc.m_nDim[i] ;
|
|
|
|
m_dMinZ[i] = vzmSrc.m_dMinZ[i] ;
|
|
m_dMaxZ[i] = vzmSrc.m_dMaxZ[i] ;
|
|
|
|
m_Values[i] = vzmSrc.m_Values[i] ;
|
|
}
|
|
|
|
m_dStep = vzmSrc.m_dStep ;
|
|
m_nStatus = vzmSrc.m_nStatus ;
|
|
m_nTempProp[0] = vzmSrc.m_nTempProp[0] ;
|
|
m_nTempProp[1] = vzmSrc.m_nTempProp[1] ;
|
|
m_dTempParam[0] = vzmSrc.m_dTempParam[0] ;
|
|
m_dTempParam[1] = vzmSrc.m_dTempParam[1] ;
|
|
m_bShowEdges = vzmSrc.m_bShowEdges ;
|
|
|
|
// dimensiono membri legati ai blocchi
|
|
m_BlockToUpdate = vzmSrc.m_BlockToUpdate ;
|
|
m_BlockUpdatingCounter = vzmSrc.m_BlockUpdatingCounter ;
|
|
m_InterBlockVox = vzmSrc.m_InterBlockVox ;
|
|
m_InterBlockOriginalSharpTria = vzmSrc.m_InterBlockOriginalSharpTria ;
|
|
m_InterBlockSharpTria = vzmSrc.m_InterBlockSharpTria ;
|
|
m_BlockSharpTria = vzmSrc.m_BlockSharpTria ;
|
|
m_BlockSmoothTria = vzmSrc.m_BlockSmoothTria ;
|
|
m_BlockBigTria = vzmSrc.m_BlockBigTria ;
|
|
m_SingleMapTria = vzmSrc.m_SingleMapTria ;
|
|
m_SliceXY = vzmSrc.m_SliceXY ;
|
|
m_SliceXZ = vzmSrc.m_SliceXZ ;
|
|
m_SliceYZ = vzmSrc.m_SliceYZ ;
|
|
|
|
// imposto ricalcolo grafica
|
|
ResetGraphics() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ResetGraphics( void)
|
|
{
|
|
m_OGrMgr.Clear() ;
|
|
for ( int nCount = 0 ; nCount < m_nNumBlock ; ++ nCount)
|
|
m_BlockToUpdate[nCount] = true ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeoObjType
|
|
VolZmap::GetType( void) const
|
|
{
|
|
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( VolZmap)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string&
|
|
VolZmap::GetTitle( void) const
|
|
{
|
|
static const string sTitle = "VolZm" ;
|
|
return sTitle ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const
|
|
{
|
|
// tipo
|
|
sOut += "Type=" + string( m_nMapNum == 1 ? "dexel" : "tridexel") + szNewLine ;
|
|
// visualizzazione spigoli
|
|
sOut += "ShowEdges=" + ToString( GetShowEdges()) + szNewLine ;
|
|
// dexel per voxel (DexToVoxRatio)
|
|
sOut += "DexVoxRat=" + ToString( m_nDexVoxRatio) + szNewLine ;
|
|
// forma
|
|
switch ( m_nShape) {
|
|
default : sOut += "Shape=generic" ; break ;
|
|
case BOX : sOut += "Shape=box" ; break ;
|
|
case EXTRUSION : sOut += "Shape=extrusion" ; break ;
|
|
}
|
|
sOut += szNewLine ;
|
|
// passo
|
|
sOut += "Step=" + ToString( GetInUiUnits( m_dStep, bMM), 6) + szNewLine ;
|
|
// dimensioni
|
|
if ( m_nMapNum == 1)
|
|
sOut += "Dim=" + ToString( m_nDim[0]) +
|
|
"(" + ToString( m_nNx[0]) + "x" + ToString( m_nNy[0]) + ")" + szNewLine ;
|
|
else {
|
|
for ( int i = 0 ; i < m_nMapNum ; ++ i)
|
|
sOut += "Dim" + ToString( i+1) + "=" + ToString( m_nDim[i]) +
|
|
"(" + ToString( m_nNx[i]) + "x" + ToString( m_nNy[i]) + ")" + szNewLine ;
|
|
}
|
|
// numero di blocchi
|
|
sOut += "Blocks=" + ToString( m_nNumBlock) + " (" + ToString( m_nFracLin[0]) + "x" +
|
|
ToString( m_nFracLin[1]) + "x" + ToString( m_nFracLin[2]) + ")" + szNewLine ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
VolZmap::GetNgeId( void) const
|
|
{
|
|
return GEOOBJ_GETNGEID( VolZmap) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Save( NgeWriter& ngeOut) const
|
|
{
|
|
// numero di mappe
|
|
if ( ! ngeOut.WriteInt( m_nMapNum, ",", false))
|
|
return false ;
|
|
// numero di blocchi
|
|
if ( ! ngeOut.WriteInt( m_nNumBlock, ",", false))
|
|
return false ;
|
|
// numero di voxel per blocco
|
|
if ( ! ngeOut.WriteInt( m_nVoxNumPerBlock, ",", false))
|
|
return false ;
|
|
// numero di blocchi per ogni asse
|
|
for ( int i = 0 ; i < 3 ; ++ i) {
|
|
if ( ! ngeOut.WriteInt( m_nFracLin[i], ",", false))
|
|
return false ;
|
|
}
|
|
// DexVoxRatio
|
|
if ( ! ngeOut.WriteInt( m_nDexVoxRatio, ",", false))
|
|
return false ;
|
|
// numero di componenti connesse
|
|
if ( ! ngeOut.WriteInt( m_nConnectedCompoCount, ",", false))
|
|
return false ;
|
|
// passo di campionamento (distanza tra spilloni)
|
|
if ( ! ngeOut.WriteDouble( m_dStep, ";", true))
|
|
return false ;
|
|
// forma
|
|
if ( ! ngeOut.WriteInt( m_nShape, ";", true))
|
|
return false ;
|
|
// sistema di riferimento
|
|
if ( ! ngeOut.WriteFrame( m_MapFrame, ";", true))
|
|
return false ;
|
|
// per ogni mappa : numero di passi in X e Y e quote Z estremali
|
|
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
|
|
if ( ! ngeOut.WriteInt( m_nNx[i], ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_nNy[i], ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_dMinZ[i], ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_dMaxZ[i], ";", true))
|
|
return false ;
|
|
}
|
|
// ciclo sulle mappe
|
|
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
|
|
// ciclo sui dexel
|
|
for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
|
|
// numero di estremi
|
|
int nDim = int( m_Values[i][j].size()) ;
|
|
if ( ! ngeOut.WriteInt( nDim, ":", false))
|
|
return false ;
|
|
// se dexel nullo
|
|
if ( nDim == 0) {
|
|
// scrivo un valore dummy
|
|
if ( ! ngeOut.WriteDouble( 0, ";", true))
|
|
return false ;
|
|
}
|
|
// altrimenti
|
|
else {
|
|
for ( int k = 0 ; k < nDim ; ++ k) {
|
|
if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dMin, ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_Values[i][j][k].nToolMin, ";", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteVector( m_Values[i][j][k].vtMinN, ";", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dMax, ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_Values[i][j][k].nToolMax, ";", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteVector( m_Values[i][j][k].vtMaxN, ";", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_Values[i][j][k].nCompo, ";", true))
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::PreSave( GdbGeo& Wrapper) const
|
|
{
|
|
// salvo il flag di visualizzazione spigoli vivi anche in shading (default false)
|
|
if ( m_bShowEdges)
|
|
Wrapper.SetInfo( GDB_SI_SHOWEDGES, true) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::PostSave( GdbGeo& Wrapper) const
|
|
{
|
|
// elimino eventuali info aggiunte nella PreSave
|
|
Wrapper.RemoveInfo( GDB_SI_SHOWEDGES) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Load( NgeReader& ngeIn)
|
|
{
|
|
Clear() ;
|
|
// numero di mappe
|
|
if ( ! ngeIn.ReadInt( m_nMapNum, ",", false))
|
|
return false ;
|
|
// numero di blocchi
|
|
if ( ! ngeIn.ReadInt( m_nNumBlock, ",", false))
|
|
return false ;
|
|
// numero di voxel per blocco
|
|
if ( ! ngeIn.ReadInt( m_nVoxNumPerBlock, ",", false))
|
|
return false ;
|
|
// numero di blocchi per ogni asse
|
|
for ( int i = 0 ; i < 3 ; ++ i) {
|
|
if ( ! ngeIn.ReadInt( m_nFracLin[i], ",", false))
|
|
return false ;
|
|
}
|
|
// da versione 1018 : aggiunto DexVoxRatio
|
|
if ( ngeIn.GetFileVersion() >= NGE_VER_1018) {
|
|
if ( ! ngeIn.ReadInt( m_nDexVoxRatio, ",", false))
|
|
return false ;
|
|
}
|
|
// numero di componenti connesse
|
|
if ( ! ngeIn.ReadInt( m_nConnectedCompoCount, ",", false))
|
|
return false ;
|
|
// passo di campionamento (distanza tra spilloni)
|
|
if ( ! ngeIn.ReadDouble( m_dStep, ";", true))
|
|
return false ;
|
|
// da versione 1014 : aggiunto flag Shape
|
|
if ( ngeIn.GetFileVersion() >= NGE_VER_1014) {
|
|
if ( ! ngeIn.ReadInt( m_nShape, ";", true))
|
|
return false ;
|
|
}
|
|
// sistema di riferimento
|
|
if ( ! ngeIn.ReadFrame( m_MapFrame, ";", true))
|
|
return false ;
|
|
// per ogni mappa : numero di passi in X e Y e quote Z estremali
|
|
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
|
|
if ( ! ngeIn.ReadInt( m_nNx[i], ",", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadInt( m_nNy[i], ",", false))
|
|
return false ;
|
|
m_nDim[i] = m_nNx[i] * m_nNy[i] ;
|
|
if ( ! ngeIn.ReadDouble( m_dMinZ[i], ",", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadDouble( m_dMaxZ[i], ";", true))
|
|
return false ;
|
|
}
|
|
// ciclo sulle mappe
|
|
for ( int i = 0 ; i < m_nMapNum ; ++ i) {
|
|
// dimensiono i vettori
|
|
m_Values[i].resize( m_nDim[i]) ;
|
|
// ciclo sui dexel
|
|
for ( int j = 0 ; j < m_nDim[i] ; ++ j) {
|
|
// leggo il numero di estremi nel dexel
|
|
int nDim ;
|
|
if ( ! ngeIn.ReadInt( nDim, ":", false))
|
|
return false ;
|
|
// se dexel nullo
|
|
if ( nDim == 0) {
|
|
// leggo un valore dummy
|
|
double dDummy ;
|
|
if ( ! ngeIn.ReadDouble( dDummy, ";", true))
|
|
return false ;
|
|
}
|
|
// altrimenti
|
|
else {
|
|
// dimensiono l'array
|
|
m_Values[i][j].resize( nDim) ;
|
|
// leggo i valori
|
|
for ( int k = 0 ; k < nDim ; ++ k) {
|
|
if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dMin, ",", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadInt( m_Values[i][j][k].nToolMin, ";", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadVector( m_Values[i][j][k].vtMinN, ";", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dMax, ",", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadInt( m_Values[i][j][k].nToolMax, ";", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadVector( m_Values[i][j][k].vtMaxN, ";", false))
|
|
return false ;
|
|
if ( ! ngeIn.ReadInt( m_Values[i][j][k].nCompo, ";", true))
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// imposto aggiornamento obbligatorio su tutti i blocchi
|
|
m_BlockToUpdate.resize( m_nNumBlock, true) ;
|
|
m_BlockUpdatingCounter.resize( m_nNumBlock + ( m_nMapNum == 1 ? 0 : 1), 0) ;
|
|
|
|
// per triangoli di feature di frontiera tra blocchi
|
|
m_InterBlockVox.resize( m_nNumBlock) ;
|
|
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
|
|
m_InterBlockSharpTria.resize( m_nNumBlock) ;
|
|
m_BlockSharpTria.resize( m_nNumBlock) ;
|
|
m_BlockSmoothTria.resize( m_nNumBlock) ;
|
|
m_BlockBigTria.resize( m_nNumBlock) ;
|
|
m_SingleMapTria.resize( m_nNumBlock) ;
|
|
m_SliceXY.resize( m_nNumBlock) ;
|
|
m_SliceXZ.resize( m_nNumBlock) ;
|
|
m_SliceYZ.resize( m_nNumBlock) ;
|
|
|
|
m_nStatus = OK ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::PostLoad( GdbGeo& Wrapper)
|
|
{
|
|
// recupero eventuale flag di visualizzazione spigoli vivi anche in shading
|
|
bool bVal ;
|
|
if ( Wrapper.GetInfo( GDB_SI_SHOWEDGES, bVal)) {
|
|
m_bShowEdges = bVal ;
|
|
Wrapper.RemoveInfo( GDB_SI_SHOWEDGES) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// reset box
|
|
b3Loc.Reset() ;
|
|
// se richiesto approssimato
|
|
if ( ( nFlag & BBF_EXACT) == 0) {
|
|
b3Loc.Add( ORIG) ;
|
|
b3Loc.Add( Point3d( m_nNx[0] * m_dStep, m_nNy[0] * m_dStep, m_dMaxZ[0])) ;
|
|
b3Loc.ToGlob( m_MapFrame) ;
|
|
return true ;
|
|
}
|
|
// calcolo preciso
|
|
// ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
|
|
double dY = 0 ;
|
|
for ( int j = 0 ; j <= m_nNy[0] ; ++ j) {
|
|
int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] - 1) ;
|
|
double dX = 0 ;
|
|
// punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
|
|
for ( int i = 0 ; i <= m_nNx[0] ; ++ i) {
|
|
int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] - 1) ;
|
|
int nPos = ic + jc * m_nNx[0] ;
|
|
if ( ! m_Values[0][nPos].empty()) {
|
|
Point3d ptP = m_MapFrame.Orig() + dX * m_MapFrame.VersX() + dY * m_MapFrame.VersY() ;
|
|
b3Loc.Add( ptP + m_Values[0][nPos][0].dMin * m_MapFrame.VersZ()) ;
|
|
b3Loc.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dMax * m_MapFrame.VersZ()) ;
|
|
}
|
|
// passo al punto successivo
|
|
dX += m_dStep ;
|
|
if ( m_nMapNum == N_MAPS)
|
|
dX = min( dX, m_dMaxZ[1]) ;
|
|
}
|
|
// passo alla riga successiva
|
|
dY += m_dStep ;
|
|
if ( m_nMapNum == N_MAPS)
|
|
dY = min( dY, m_dMaxZ[2]) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// reset box
|
|
b3Ref.Reset() ;
|
|
// trasformo il riferimento locale tramite quello passato
|
|
Frame3d frUse = m_MapFrame ;
|
|
frUse.ToGlob( frRef) ;
|
|
// se richiesto approssimato
|
|
if ( ( nFlag & BBF_EXACT) == 0) {
|
|
b3Ref.Add( ORIG) ;
|
|
b3Ref.Add( Point3d( m_nNx[0] * m_dStep, m_nNy[0] * m_dStep, m_dMaxZ[0])) ;
|
|
b3Ref.ToGlob( frUse) ;
|
|
return true ;
|
|
}
|
|
// calcolo preciso
|
|
// ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
|
|
double dY = 0 ;
|
|
for ( int j = 0 ; j <= m_nNy[0] ; ++ j) {
|
|
int jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] - 1) ;
|
|
double dX = 0 ;
|
|
// punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
|
|
for ( int i = 0 ; i <= m_nNx[0] ; ++ i) {
|
|
int ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] - 1) ;
|
|
int nPos = ic + jc * m_nNx[0] ;
|
|
if ( nPos >= 0 && ! m_Values[0][nPos].empty()) {
|
|
Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ;
|
|
b3Ref.Add( ptP + m_Values[0][nPos][0].dMin * frUse.VersZ()) ;
|
|
b3Ref.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dMax * frUse.VersZ()) ;
|
|
}
|
|
// passo al punto successivo
|
|
dX += m_dStep ;
|
|
if ( m_nMapNum == N_MAPS)
|
|
dX = min( dX, m_dMaxZ[1]) ;
|
|
}
|
|
// passo alla riga successiva
|
|
dY += m_dStep ;
|
|
if ( m_nMapNum == N_MAPS)
|
|
dY = min( dY, m_dMaxZ[2]) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::GetPartLocalBBox( int nPart, BBox3d& b3Loc, int nFlag) const
|
|
{
|
|
// Verifico lo stato.
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// Se una sola mappa o il numero di componenti è indefinito, vi è un errore.
|
|
if ( m_nMapNum == 1 || m_nConnectedCompoCount == - 1)
|
|
return false ;
|
|
// Se la componente richiesta non esiste, vi è un errore.
|
|
if ( nPart < 0 || nPart > m_nConnectedCompoCount - 1)
|
|
return false ;
|
|
// Calcolo Bounding-box
|
|
for ( int nMap = 0 ; nMap < 3 ; ++ nMap) {
|
|
for ( int nDex = 0 ; nDex < m_nDim[nMap] ; ++ nDex) {
|
|
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
|
|
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nMap] ;
|
|
int nJ = nDex / m_nNx[nMap] ;
|
|
// Posizione del dexel
|
|
double dX = ( nI + 0.5) * m_dStep ;
|
|
double dY = ( nJ + 0.5) * m_dStep ;
|
|
// Definisco i punti nel sistema locale
|
|
Point3d ptP, ptPSt, ptPEn ;
|
|
if ( nMap == 0) {
|
|
ptP = m_MapFrame.Orig() + dX * m_MapFrame.VersX() + dY * m_MapFrame.VersY() ;
|
|
ptPSt = ptP + m_Values[nMap][nDex][nInt].dMin * m_MapFrame.VersZ() ;
|
|
ptPEn = ptP + m_Values[nMap][nDex][nInt].dMax * m_MapFrame.VersZ() ;
|
|
}
|
|
else if ( nMap == 1) {
|
|
ptP = m_MapFrame.Orig() + dX * m_MapFrame.VersY() + dY * m_MapFrame.VersZ() ;
|
|
ptPSt = ptP + m_Values[nMap][nDex][nInt].dMin * m_MapFrame.VersX() ;
|
|
ptPEn = ptP + m_Values[nMap][nDex][nInt].dMax * m_MapFrame.VersX() ;
|
|
}
|
|
else {
|
|
ptP = m_MapFrame.Orig() + dX * m_MapFrame.VersZ() + dY * m_MapFrame.VersX() ;
|
|
ptPSt = ptP + m_Values[nMap][nDex][nInt].dMin * m_MapFrame.VersY() ;
|
|
ptPEn = ptP + m_Values[nMap][nDex][nInt].dMax * m_MapFrame.VersY() ;
|
|
}
|
|
// Aggiungo i punti al bounding-box
|
|
b3Loc.Add( ptPSt) ;
|
|
b3Loc.Add( ptPEn) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::GetPartBBox( int nPart, const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
|
|
{
|
|
// Verifico lo stato.
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// Se una sola mappa o il numero di componenti è indefinito, vi è un errore.
|
|
if ( m_nMapNum == 1 || m_nConnectedCompoCount == - 1)
|
|
return false ;
|
|
// Se la componente richiesta non esiste, vi è un errore.
|
|
if ( nPart < 0 || nPart > m_nConnectedCompoCount - 1)
|
|
return false ;
|
|
// Calcolo Bounding-box
|
|
Point3d ptMapFrameOrig = m_MapFrame.Orig() ;
|
|
Vector3d vtMapFrameVersX = m_MapFrame.VersX() ;
|
|
Vector3d vtMapFrameVersY = m_MapFrame.VersY() ;
|
|
Vector3d vtMapFrameVersZ = m_MapFrame.VersZ() ;
|
|
ptMapFrameOrig.ToGlob( frRef) ;
|
|
vtMapFrameVersX.ToGlob( frRef) ;
|
|
vtMapFrameVersY.ToGlob( frRef) ;
|
|
vtMapFrameVersZ.ToGlob( frRef) ;
|
|
for ( int nMap = 0 ; nMap < 3 ; ++ nMap) {
|
|
for ( int nDex = 0 ; nDex < m_nDim[nMap] ; ++ nDex) {
|
|
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
|
|
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nMap] ;
|
|
int nJ = nDex / m_nNx[nMap] ;
|
|
// Posizione del dexel
|
|
double dX = ( nI + 0.5) * m_dStep ;
|
|
double dY = ( nJ + 0.5) * m_dStep ;
|
|
// Definisco i punti nel sistema locale
|
|
Point3d ptP, ptPSt, ptPEn ;
|
|
if ( nMap == 0) {
|
|
ptP = ptMapFrameOrig + dX * vtMapFrameVersX + dY * vtMapFrameVersY ;
|
|
ptPSt = ptP + m_Values[nMap][nDex][nInt].dMin * vtMapFrameVersZ ;
|
|
ptPEn = ptP + m_Values[nMap][nDex][nInt].dMax * vtMapFrameVersZ ;
|
|
}
|
|
else if ( nMap == 1) {
|
|
ptP = ptMapFrameOrig + dX * vtMapFrameVersY + dY * vtMapFrameVersZ ;
|
|
ptPSt = ptP + m_Values[nMap][nDex][nInt].dMin * vtMapFrameVersX ;
|
|
ptPEn = ptP + m_Values[nMap][nDex][nInt].dMax * vtMapFrameVersX ;
|
|
}
|
|
else {
|
|
ptP = ptMapFrameOrig + dX * vtMapFrameVersZ + dY * vtMapFrameVersX ;
|
|
ptPSt = ptP + m_Values[nMap][nDex][nInt].dMin * vtMapFrameVersY ;
|
|
ptPEn = ptP + m_Values[nMap][nDex][nInt].dMax * vtMapFrameVersY ;
|
|
}
|
|
// Aggiungo i punti al bounding-box
|
|
b3Ref.Add( ptPSt) ;
|
|
b3Ref.Add( ptPEn) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Translate( const Vector3d& vtMove)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetGraphics() ;
|
|
|
|
// traslo il riferimento
|
|
m_MapFrame.Translate( vtMove) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità dell'asse di rotazione
|
|
if ( vtAx.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetGraphics() ;
|
|
|
|
// ruoto il riferimento
|
|
m_MapFrame.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico non sia nulla
|
|
if ( abs( dCoeffX) < EPS_ZERO && abs( dCoeffY) < EPS_ZERO && abs( dCoeffZ) < EPS_ZERO)
|
|
return false ;
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del piano di specchiatura
|
|
if ( vtNorm.IsSmall())
|
|
return false ;
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità dei parametri
|
|
if ( vtNorm.IsSmall() || vtDir.IsSmall())
|
|
return false ;
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ToGlob( const Frame3d& frRef)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// se frame identità, non devo fare alcunché
|
|
if ( IsGlobFrame( frRef))
|
|
return true ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetGraphics() ;
|
|
|
|
// trasformo il riferimento
|
|
m_MapFrame.ToGlob( frRef) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ToLoc( const Frame3d& frRef)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// se frame identità, non devo fare alcunché
|
|
if ( IsGlobFrame( frRef))
|
|
return true ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetGraphics() ;
|
|
|
|
// trasformo il riferimento
|
|
m_MapFrame.ToLoc( frRef) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità dei frame
|
|
if ( frOri.GetType() == Frame3d::ERR || frDest.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// se i due riferimenti coincidono, non devo fare alcunché
|
|
if ( AreSameFrame( frOri, frDest))
|
|
return true ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
ResetGraphics() ;
|
|
|
|
// trasformo il riferimento
|
|
m_MapFrame.LocToLoc( frOri, frDest) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
VolZmap::GetPartCount( void) const
|
|
{
|
|
// Se mono-dexel la connessione è incalcolabile.
|
|
if ( m_nMapNum == 1)
|
|
return - 1 ;
|
|
// Se il numero delle componenti è indefinito
|
|
// lo ricalcolo e restituisco il risultato.
|
|
if ( m_nConnectedCompoCount == - 1) {
|
|
const_cast<VolZmap*>(this)->CheckMapConnection() ;
|
|
return m_nConnectedCompoCount ;
|
|
}
|
|
// Altrimenti restituisco direttamente il numero di componenti.
|
|
else
|
|
return m_nConnectedCompoCount ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::CheckMapConnection( void)
|
|
{
|
|
// Imposto il numero di componenti connesse a 0
|
|
m_nConnectedCompoCount = 0 ;
|
|
// Imposto a 0 tutti il valore del numero della componente
|
|
// connessa di ciascun tratto di ciascun dexel.
|
|
for ( int tMap = 0 ; tMap < m_nMapNum ; ++ tMap) {
|
|
for ( int tDex = 0 ; tDex < m_nDim[tMap] ; ++ tDex) {
|
|
for ( int tInt = 0 ; tInt < int( m_Values[tMap][tDex].size()) ; ++ tInt) {
|
|
m_Values[tMap][tDex][tInt].nCompo = 0 ;
|
|
}
|
|
}
|
|
}
|
|
// Numero massimo di thread
|
|
int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
|
|
// Ciclo sui dexel lungo Z
|
|
for ( int tI = 0 ; tI < m_nNx[0] ; ++ tI) {
|
|
for ( int tJ = 0 ; tJ < m_nNy[0] ; ++ tJ) {
|
|
// Numero del dexel lungo Z
|
|
int tDexZ = tJ * m_nNx[0] + tI ;
|
|
// Numero di intervalli nel dexel
|
|
int tStopIntZ = int( m_Values[0][tDexZ].size()) ;
|
|
// Ciclo sugli intervalli del dexel
|
|
for ( int tIntZ = 0 ; tIntZ < tStopIntZ ; ++ tIntZ) {
|
|
if ( m_Values[0][tDexZ][tIntZ].nCompo == 0) {
|
|
++ m_nConnectedCompoCount ;
|
|
m_Values[0][tDexZ][tIntZ].nCompo = m_nConnectedCompoCount ;
|
|
// Espando in tutta la componente
|
|
// Segmento corrente
|
|
IntervalIndexes NewInt ;
|
|
NewInt.tMap = 0 ;
|
|
NewInt.tDex = tJ * m_nNx[0] + tI ;
|
|
NewInt.tInt = tIntZ ;
|
|
// Vettore di stack di segmenti
|
|
IntContainerVec IntervalsToProcessStackVec ;
|
|
IntervalsToProcessStackVec.resize( nThreadMax) ;
|
|
// Mi espando dal primo intervallo mettendo gli intervalli che intersecano nei vari thread
|
|
FirstExpansionFromZ( nThreadMax, NewInt, IntervalsToProcessStackVec) ;
|
|
// Lancio in parallelo più ricerche
|
|
int nActiveThread = 0 ;
|
|
vector<future<bool>> vRes ;
|
|
vRes.resize( nThreadMax) ;
|
|
for ( int i = 0 ; i < nThreadMax ; ++ i) {
|
|
if ( ! IntervalsToProcessStackVec[i].empty()) {
|
|
++ nActiveThread ;
|
|
vRes[i] = async( launch::async, &VolZmap::ProcessIntervals, this, ref( IntervalsToProcessStackVec[i])) ;
|
|
}
|
|
}
|
|
// Attendo che tutti i porcessi terminino
|
|
int nTerminated = 0 ;
|
|
while ( nTerminated < nActiveThread) {
|
|
for ( int i = 0 ; i < nThreadMax ; ++ i) {
|
|
if ( vRes[i].valid() && vRes[i].wait_for( chrono::nanoseconds{ 1}) == future_status::ready) {
|
|
vRes[i].get() ;
|
|
++ nTerminated ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Se l'intervallo non attraversa un nodo o ha già
|
|
// un indice assegnato salto questa iterazione.
|
|
else
|
|
continue ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ExpandFromXInterval( IntContainer& IntCont)
|
|
{
|
|
// Copio i dati dell'intervallo corrente
|
|
IntervalIndexes CurrInterval = IntCont.top() ;
|
|
IntCont.pop() ;
|
|
int tDex = CurrInterval.tDex ;
|
|
int tGrIndex1 = CurrInterval.tDex % m_nNx[1] ;
|
|
int tGrIndex2 = CurrInterval.tDex / m_nNx[1] ;
|
|
int tInt = CurrInterval.tInt ;
|
|
// Quote estreme del segmento lungo X
|
|
double dMinX = m_Values[1][tDex][tInt].dMin ;
|
|
double dMaxX = m_Values[1][tDex][tInt].dMax ;
|
|
double dMinDX = max( floor( ( dMinX - 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
double dMaxDX = max( floor( ( dMaxX + 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
// Indici estremi dei dei dexel ortogonali
|
|
// che possono intersecare il segmento di partenza
|
|
int tStartI = min( int( dMinDX), ( m_nNx[0] - 1)) ;
|
|
int tStopI = min( int( dMaxDX), ( m_nNx[0] - 1)) ;
|
|
// Posizione YZ del dexel
|
|
double dY = ( tGrIndex1 + 0.5) * m_dStep ;
|
|
double dZ = ( tGrIndex2 + 0.5) * m_dStep ;
|
|
// Ciclo sugli indici dei dexel che potrebbero
|
|
// intersecare il segmento di partenza
|
|
for ( int tI = tStartI ; tI <= tStopI ; ++ tI) {
|
|
// Analizzo i dexel della griglia 0.
|
|
int tStopZ = int( m_Values[0][tGrIndex1 * m_nNx[0] + tI].size()) ;
|
|
for ( int tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) {
|
|
// Estremi del dexel lunog Z
|
|
double dZmin = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMin ;
|
|
double dZmax = m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dZmin - 2 * EPS_SMALL < dZ &&
|
|
dZmax + 2 * EPS_SMALL > dZ &&
|
|
m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].nCompo == 0) {
|
|
m_Values[0][tGrIndex1 * m_nNx[0] + tI][tIntZ].nCompo = m_Values[1][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 0 ;
|
|
NewInterval.tDex = tGrIndex1 * m_nNx[0] + tI ;
|
|
NewInterval.tInt = tIntZ ;
|
|
IntCont.push( NewInterval) ;
|
|
}
|
|
}
|
|
// Analizzo i dexel della griglia 2
|
|
int tStopY = int( m_Values[2][tI * m_nNx[2] + tGrIndex2].size()) ;
|
|
for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
|
|
// Estremi del segmento del dexel lungo Y
|
|
double dYmin = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMin ;
|
|
double dYmax = m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dYmin - 2 * EPS_SMALL < dY &&
|
|
dYmax + 2 * EPS_SMALL > dY &&
|
|
m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].nCompo == 0) {
|
|
m_Values[2][tI * m_nNx[2] + tGrIndex2][tIntY].nCompo = m_Values[1][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 2 ;
|
|
NewInterval.tDex = tI * m_nNx[2] + tGrIndex2 ;
|
|
NewInterval.tInt = tIntY ;
|
|
IntCont.push( NewInterval) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ExpandFromYInterval( IntContainer& IntCont)
|
|
{
|
|
// Copio i dati dell'intervallo corrente
|
|
IntervalIndexes CurrInterval = IntCont.top() ;
|
|
IntCont.pop() ;
|
|
int tDex = CurrInterval.tDex ;
|
|
int tGrIndex1 = CurrInterval.tDex % m_nNx[2] ;
|
|
int tGrIndex2 = CurrInterval.tDex / m_nNx[2] ;
|
|
int tInt = CurrInterval.tInt ;
|
|
// Quote estreme del segmento lungo Y
|
|
double dMinY = m_Values[2][tDex][tInt].dMin ;
|
|
double dMaxY = m_Values[2][tDex][tInt].dMax ;
|
|
double dMinDY = max( floor( ( dMinY - 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
double dMaxDY = max( floor( ( dMaxY + 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
// Indici estremi dei dei dexel ortogonali
|
|
// che possono intersecare il segmento di partenza
|
|
int tStartJ = min( int( dMinDY), ( m_nNy[0] - 1)) ;
|
|
int tStopJ = min( int( dMaxDY), ( m_nNy[0] - 1)) ;
|
|
// Posizione XZ del dexel
|
|
double dX = ( tGrIndex2 + 0.5) * m_dStep ;
|
|
double dZ = ( tGrIndex1 + 0.5) * m_dStep ;
|
|
// Ciclo sugli indici dei dexel che potrebbero
|
|
// intersecare il segmento di partenza
|
|
for ( int tJ = tStartJ ; tJ <= tStopJ ; ++ tJ) {
|
|
// Analizzo i dexel della griglia 0.
|
|
int tStopZ = int( m_Values[0][tJ * m_nNx[0] + tGrIndex2].size()) ;
|
|
for ( int tIntZ = 0 ; tIntZ < tStopZ ; ++ tIntZ) {
|
|
// Estremi del dexel lunog Z
|
|
double dZmin = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMin ;
|
|
double dZmax = m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dZmin - 2 * EPS_SMALL < dZ &&
|
|
dZmax + 2 * EPS_SMALL > dZ &&
|
|
m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].nCompo == 0) {
|
|
m_Values[0][tJ * m_nNx[0] + tGrIndex2][tIntZ].nCompo = m_Values[2][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 0 ;
|
|
NewInterval.tDex = tJ * m_nNx[0] + tGrIndex2 ;
|
|
NewInterval.tInt = tIntZ ;
|
|
IntCont.push( NewInterval) ;
|
|
}
|
|
}
|
|
// Analizzo i dexel della griglia 1
|
|
int tStopX = int( m_Values[1][tGrIndex1 * m_nNx[1] + tJ].size()) ;
|
|
for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
|
|
// Estremi del segmento del dexel lungo X
|
|
double dXmin = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMin ;
|
|
double dXmax = m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dXmin - 2 * EPS_SMALL < dX &&
|
|
dXmax + 2 * EPS_SMALL > dX &&
|
|
m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].nCompo == 0) {
|
|
m_Values[1][tGrIndex1 * m_nNx[1] + tJ][tIntX].nCompo = m_Values[2][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 1 ;
|
|
NewInterval.tDex = tGrIndex1 * m_nNx[1] + tJ ;
|
|
NewInterval.tInt = tIntX ;
|
|
IntCont.push( NewInterval) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ExpandFromZInterval( IntContainer& IntCont)
|
|
{
|
|
// Copio i dati dell'intervallo corrente
|
|
IntervalIndexes CurrInterval = IntCont.top() ;
|
|
IntCont.pop() ;
|
|
int tDex = CurrInterval.tDex ;
|
|
int tGrIndex1 = CurrInterval.tDex % m_nNx[0] ;
|
|
int tGrIndex2 = CurrInterval.tDex / m_nNx[0] ;
|
|
int tInt = CurrInterval.tInt ;
|
|
// Quote estreme del segmento lungo Z
|
|
double dMinZ = m_Values[0][tDex][tInt].dMin ;
|
|
double dMaxZ = m_Values[0][tDex][tInt].dMax ;
|
|
double dMinDZ = max( floor( ( dMinZ - 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
double dMaxDZ = max( floor( ( dMaxZ + 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
// Indici estremi dei dexel ortogonali
|
|
// che possono intersecare il segmento di partenza
|
|
int tStartK = min( int( dMinDZ), ( m_nNy[1] - 1)) ;
|
|
int tStopK = min( int( dMaxDZ), ( m_nNy[1] - 1)) ;
|
|
// Posizione XY del dexel
|
|
double dX = ( tGrIndex1 + 0.5) * m_dStep ;
|
|
double dY = ( tGrIndex2 + 0.5) * m_dStep ;
|
|
// Ciclo sugli indici dei dexel che potrebbero
|
|
// intersecare il segmento di partenza
|
|
for ( int tK = tStartK ; tK <= tStopK ; ++ tK) {
|
|
// Analizzo i dexel della griglia 1.
|
|
int tStopX = int( m_Values[1][tK * m_nNx[1] + tGrIndex2].size()) ;
|
|
for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
|
|
// Estremi del segmento del dexel lungo X
|
|
double dXmin = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMin ;
|
|
double dXmax = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dXmin - 2 * EPS_SMALL < dX &&
|
|
dXmax + 2 * EPS_SMALL > dX &&
|
|
m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo == 0) {
|
|
m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo = m_Values[0][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 1 ;
|
|
NewInterval.tDex = tK * m_nNx[1] + tGrIndex2 ;
|
|
NewInterval.tInt = tIntX ;
|
|
IntCont.push( NewInterval) ;
|
|
}
|
|
}
|
|
// Analizzo i dexel della griglia 2
|
|
int tStopY = int( m_Values[2][tGrIndex1 * m_nNx[2] + tK].size()) ;
|
|
for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
|
|
// Estremi del segmento del dexel lungo Y
|
|
double dYmin = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMin ;
|
|
double dYmax = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dYmin - 2 * EPS_SMALL < dY &&
|
|
dYmax + 2 * EPS_SMALL > dY &&
|
|
m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo == 0) {
|
|
m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo = m_Values[0][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 2 ;
|
|
NewInterval.tDex = tGrIndex1 * m_nNx[2] + tK ;
|
|
NewInterval.tInt = tIntY ;
|
|
IntCont.push( NewInterval) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::FirstExpansionFromZ( int nNumThread, IntervalIndexes IntSt, IntContainerVec& IntervalsToProcessStackVec)
|
|
{
|
|
int tDex = IntSt.tDex ;
|
|
int tGrIndex1 = IntSt.tDex % m_nNx[0] ;
|
|
int tGrIndex2 = IntSt.tDex / m_nNx[0] ;
|
|
int tInt = IntSt.tInt ;
|
|
// Quote estreme del segmento lungo Z
|
|
double dMinZ = m_Values[0][tDex][tInt].dMin ;
|
|
double dMaxZ = m_Values[0][tDex][tInt].dMax ;
|
|
double dMinDZ = max( floor( ( dMinZ - 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
double dMaxDZ = max( floor( ( dMaxZ + 2 * EPS_SMALL) / m_dStep - 0.5), 0.) ;
|
|
// Indici estremi dei dexel ortogonali
|
|
// che possono intersecare il segmento di partenza
|
|
int tStartK = min( int( dMinDZ), ( m_nNy[1] - 1)) ;
|
|
int tStopK = min( int( dMaxDZ), ( m_nNy[1] - 1)) ;
|
|
// Posizione XY del dexel
|
|
double dX = ( tGrIndex1 + 0.5) * m_dStep ;
|
|
double dY = ( tGrIndex2 + 0.5) * m_dStep ;
|
|
// Ciclo sugli indici dei dexel che potrebbero
|
|
// intersecare il segmento di partenza
|
|
int nCurStack = 0 ;
|
|
for ( int tK = tStartK ; tK <= tStopK ; ++ tK) {
|
|
// Analizzo i dexel della griglia 1.
|
|
int tStopX = int( m_Values[1][tK * m_nNx[1] + tGrIndex2].size()) ;
|
|
for ( int tIntX = 0 ; tIntX < tStopX ; ++ tIntX) {
|
|
// Estremi del segmento del dexel lungo X
|
|
double dXmin = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMin ;
|
|
double dXmax = m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dXmin - 2 * EPS_SMALL < dX &&
|
|
dXmax + 2 * EPS_SMALL > dX &&
|
|
m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo == 0) {
|
|
m_Values[1][tK * m_nNx[1] + tGrIndex2][tIntX].nCompo = m_Values[0][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 1 ;
|
|
NewInterval.tDex = tK * m_nNx[1] + tGrIndex2 ;
|
|
NewInterval.tInt = tIntX ;
|
|
IntervalsToProcessStackVec[nCurStack].push( NewInterval) ;
|
|
nCurStack = ( ++ nCurStack) % int( IntervalsToProcessStackVec.size()) ;
|
|
}
|
|
}
|
|
// Analizzo i dexel della griglia 2
|
|
int tStopY = int( m_Values[2][tGrIndex1 * m_nNx[2] + tK].size()) ;
|
|
for ( int tIntY = 0 ; tIntY < tStopY ; ++ tIntY) {
|
|
// Estremi del segmento del dexel lungo Y
|
|
double dYmin = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMin ;
|
|
double dYmax = m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].dMax ;
|
|
// Se i segmenti si incrociano e il nuovo trovato non
|
|
// ha già un indice assegnato, assegno l'indice e
|
|
// aggiungo l'intervallo trovato allo stack.
|
|
if ( dYmin - 2 * EPS_SMALL < dY &&
|
|
dYmax + 2 * EPS_SMALL > dY &&
|
|
m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo == 0) {
|
|
m_Values[2][tGrIndex1 * m_nNx[2] + tK][tIntY].nCompo = m_Values[0][tDex][tInt].nCompo ;
|
|
IntervalIndexes NewInterval ;
|
|
NewInterval.tMap = 2 ;
|
|
NewInterval.tDex = tGrIndex1 * m_nNx[2] + tK ;
|
|
NewInterval.tInt = tIntY ;
|
|
IntervalsToProcessStackVec[nCurStack].push( NewInterval) ;
|
|
nCurStack = ( ++ nCurStack) % int( IntervalsToProcessStackVec.size()) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ProcessIntervals( IntContainer& IntervalsToProcess)
|
|
{
|
|
// Processo gli intervalli trovati
|
|
while ( ! IntervalsToProcess.empty()) {
|
|
switch ( IntervalsToProcess.top().tMap) {
|
|
case 0:
|
|
ExpandFromZInterval( IntervalsToProcess) ;
|
|
break ;
|
|
case 1:
|
|
ExpandFromXInterval( IntervalsToProcess) ;
|
|
break ;
|
|
case 2:
|
|
ExpandFromYInterval( IntervalsToProcess) ;
|
|
break ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VolZmap*
|
|
VolZmap::ClonePart( int nPart) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return nullptr ;
|
|
// Se è definita una sola griglia non sono definibili le parti, errore
|
|
if ( m_nMapNum == 1)
|
|
return nullptr ;
|
|
// Se è richiesta una componente fuori intervallo, errore
|
|
if ( nPart < 0 || nPart >= m_nConnectedCompoCount)
|
|
return nullptr ;
|
|
// Se il numero di componenti è indefinito, lo ricalcolo.
|
|
if ( m_nConnectedCompoCount == - 1)
|
|
const_cast<VolZmap*>(this)->CheckMapConnection() ;
|
|
// Se non vi sono componenti, errore
|
|
if ( m_nConnectedCompoCount == 0)
|
|
return nullptr ;
|
|
// Creo nuovo oggetto Zmap
|
|
PtrOwner<VolZmap> pVolume( CreateBasicVolZmap()) ;
|
|
if ( IsNull( pVolume))
|
|
return nullptr ;
|
|
// Setto per il nuovo Zmap le seguenti variabili
|
|
pVolume->m_nConnectedCompoCount = 1 ;
|
|
pVolume->m_dStep = m_dStep ;
|
|
pVolume->m_nMapNum = m_nMapNum ;
|
|
|
|
// Minimi e massimi indici i,j della componente per le tre griglie
|
|
int nMinIndI[N_MAPS] ;
|
|
int nMaxIndI[N_MAPS] ;
|
|
int nMinIndJ[N_MAPS] ;
|
|
int nMaxIndJ[N_MAPS] ;
|
|
// Coordinate dell'origine del sistema di riferimento
|
|
// del nuovo Zmap
|
|
double dNewOx, dNewOy, dNewOz ;
|
|
// Ciclo sulle mappe
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
nMinIndI[nMap] = m_nNx[nMap] ;
|
|
nMinIndJ[nMap] = m_nNy[nMap] ;
|
|
nMaxIndI[nMap] = 0 ;
|
|
nMaxIndJ[nMap] = 0 ;
|
|
pVolume->m_dMinZ[nMap] = m_dMaxZ[nMap] ;
|
|
pVolume->m_dMaxZ[nMap] = m_dMinZ[nMap] ;
|
|
// Della componente connessa in questione calcolo indici i e j massimi e minimi.
|
|
// Inoltre cerco la minima e massima Z.
|
|
for ( int nIndI = 0 ; nIndI < int( m_nNx[nMap]) ; ++ nIndI) {
|
|
for ( int nIndJ = 0 ; nIndJ < int( m_nNy[nMap]) ; ++ nIndJ) {
|
|
int nDex = nIndJ * m_nNx[nMap] + nIndI ;
|
|
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
|
|
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
|
|
if ( nIndI < nMinIndI[nMap])
|
|
nMinIndI[nMap] = nIndI ;
|
|
if ( nIndJ < nMinIndJ[nMap])
|
|
nMinIndJ[nMap] = nIndJ ;
|
|
if ( nIndI > nMaxIndI[nMap])
|
|
nMaxIndI[nMap] = nIndI ;
|
|
if ( nIndJ > nMaxIndJ[nMap])
|
|
nMaxIndJ[nMap] = nIndJ ;
|
|
if ( m_Values[nMap][nDex][nInt].dMin < pVolume->m_dMinZ[nMap])
|
|
pVolume->m_dMinZ[nMap] = m_Values[nMap][nDex][nInt].dMin ;
|
|
if ( m_Values[nMap][nDex][nInt].dMax > pVolume->m_dMaxZ[nMap])
|
|
pVolume->m_dMaxZ[nMap] = m_Values[nMap][nDex][nInt].dMax ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
if ( nMinIndI[nMap] > 0)
|
|
-- nMinIndI[nMap] ;
|
|
if ( nMaxIndI[nMap] < int( m_nNx[nMap]) - 1)
|
|
++ nMaxIndI[nMap] ;
|
|
if ( nMinIndJ[nMap] > 0)
|
|
-- nMinIndJ[nMap] ;
|
|
if ( nMaxIndJ[nMap] < int( m_nNy[nMap]) - 1)
|
|
++ nMaxIndJ[nMap] ;
|
|
pVolume->m_nNx[nMap] = max( 0, nMaxIndI[nMap] - nMinIndI[nMap] + 1) ;
|
|
pVolume->m_nNy[nMap] = max( 0, nMaxIndJ[nMap] - nMinIndJ[nMap] + 1) ;
|
|
pVolume->m_nDim[nMap] = pVolume->m_nNx[nMap] * pVolume->m_nNy[nMap] ;
|
|
pVolume->m_Values[nMap].resize( pVolume->m_nDim[nMap]) ;
|
|
}
|
|
|
|
// Se almeno una griglia è nulla, non ha senso Zmap
|
|
if ( pVolume->m_nDim[0] == 0 ||
|
|
pVolume->m_nDim[1] == 0 ||
|
|
pVolume->m_nDim[2] == 0)
|
|
return nullptr ;
|
|
|
|
// Copio gli intervalli nelle griglie del nuovo oggetto:
|
|
// Griglia 0
|
|
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[0]) ; ++ nIndJ) {
|
|
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[0]) ; ++ nIndI) {
|
|
int nNewDex = nIndJ * pVolume->m_nNx[0] + nIndI ;
|
|
int nOldDex = ( nIndJ + nMinIndJ[0]) * m_nNx[0] + nIndI + nMinIndI[0] ;
|
|
for ( int nInt = 0 ; nInt < int( m_Values[0][nOldDex].size()) ; ++ nInt) {
|
|
if ( m_Values[0][nOldDex][nInt].nCompo == nPart + 1) {
|
|
pVolume->m_Values[0][nNewDex].emplace_back( m_Values[0][nOldDex][nInt]) ;
|
|
pVolume->m_Values[0][nNewDex].back().nCompo = 1 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Griglia 1
|
|
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[1]) ; ++ nIndJ) {
|
|
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[1]) ; ++ nIndI) {
|
|
int nNewDex = nIndJ * pVolume->m_nNx[1] + nIndI ;
|
|
int nOldDex = ( nIndJ + nMinIndJ[1]) * m_nNx[1] + nIndI + nMinIndI[1] ;
|
|
for ( int nInt = 0 ; nInt < int( m_Values[1][nOldDex].size()) ; ++ nInt) {
|
|
if ( m_Values[1][nOldDex][nInt].nCompo == nPart + 1) {
|
|
pVolume->m_Values[1][nNewDex].emplace_back( m_Values[1][nOldDex][nInt]) ;
|
|
pVolume->m_Values[1][nNewDex].back().nCompo = 1 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Griglia 2
|
|
for ( int nIndJ = 0 ; nIndJ < int( pVolume->m_nNy[2]) ; ++ nIndJ) {
|
|
for ( int nIndI = 0 ; nIndI < int( pVolume->m_nNx[2]) ; ++ nIndI) {
|
|
int nNewDex = nIndJ * pVolume->m_nNx[2] + nIndI ;
|
|
int nOldDex = ( nIndJ + nMinIndJ[2]) * m_nNx[2] + nIndI + nMinIndI[2] ;
|
|
for ( int nInt = 0 ; nInt < int( m_Values[2][nOldDex].size()) ; ++ nInt) {
|
|
if ( m_Values[2][nOldDex][nInt].nCompo == nPart + 1) {
|
|
pVolume->m_Values[2][nNewDex].emplace_back( m_Values[2][nOldDex][nInt]) ;
|
|
pVolume->m_Values[2][nNewDex].back().nCompo = 1 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Coordinate x,y dell'origine del sistema di riferimento
|
|
dNewOx = nMinIndI[0] * m_dStep ;
|
|
dNewOy = nMinIndJ[0] * m_dStep ;
|
|
dNewOz = nMinIndJ[1] * m_dStep ;
|
|
|
|
// Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
|
|
// infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
// Quote estreme Z
|
|
switch ( nMap) {
|
|
case 0 :
|
|
pVolume->m_dMinZ[nMap] -= dNewOz ;
|
|
pVolume->m_dMaxZ[nMap] -= dNewOz ;
|
|
break ;
|
|
case 1 :
|
|
pVolume->m_dMinZ[nMap] -= dNewOx ;
|
|
pVolume->m_dMaxZ[nMap] -= dNewOx ;
|
|
break ;
|
|
case 2 :
|
|
pVolume->m_dMinZ[nMap] -= dNewOy ;
|
|
pVolume->m_dMaxZ[nMap] -= dNewOy ;
|
|
break ;
|
|
}
|
|
// Dexel
|
|
for ( int nDex = 0 ; nDex < int( pVolume->m_nDim[nMap]) ; ++ nDex) {
|
|
for ( int nInt = 0 ; nInt < int( pVolume->m_Values[nMap][nDex].size()) ; ++ nInt) {
|
|
switch ( nMap) {
|
|
case 0 :
|
|
pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOz ;
|
|
pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOz ;
|
|
break ;
|
|
case 1 :
|
|
pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOx ;
|
|
pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOx ;
|
|
break ;
|
|
case 2 :
|
|
pVolume->m_Values[nMap][nDex][nInt].dMin -= dNewOy ;
|
|
pVolume->m_Values[nMap][nDex][nInt].dMax -= dNewOy ;
|
|
break ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Definisco il numero di blocchi lungo x,y e z
|
|
if ( ! pVolume->CalcBlockNum())
|
|
return nullptr ;
|
|
|
|
// Sistema di riferimento intrinseco del nuovo solido
|
|
Point3d ptNewO = m_MapFrame.Orig() + Vector3d( dNewOx, dNewOy, dNewOz) ;
|
|
pVolume->m_MapFrame.Set( ptNewO, X_AX, Y_AX, Z_AX) ;
|
|
|
|
// Determino la forma
|
|
pVolume->m_nShape = ( pVolume->IsBox() ? BOX : GENERIC) ;
|
|
|
|
// Setto lo stato del nuovo Solido
|
|
pVolume->m_nStatus = m_nStatus ;
|
|
|
|
// Restituisco il nuovo solido
|
|
return Release( pVolume) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::RemovePart( int nPart)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// Se è definita una sola griglia non sono definibili le parti, errore
|
|
if ( m_nMapNum == 1)
|
|
return false ;
|
|
// Se il numero di componenti è indefinito, lo ricalcolo
|
|
if ( m_nConnectedCompoCount == - 1)
|
|
CheckMapConnection() ;
|
|
// Se non vi sono componenti, abbiamo finito
|
|
if ( m_nConnectedCompoCount == 0)
|
|
return true ;
|
|
|
|
// Elimino i segmenti con indice nPart + 1 e aggiorno quelli con indice superiore
|
|
// Ciclo sulle mappe.
|
|
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
|
|
// Ciclo sui dexel della mappa.
|
|
for ( int nDex = 0 ; nDex < int( m_Values[nMap].size()) ; ++ nDex) {
|
|
// Ciclo sugli intervalli del dexel.
|
|
for ( int nInt = 0 ; nInt < int( m_Values[nMap][nDex].size()) ; ++ nInt) {
|
|
// Se l'intervallo appartiene alla componente da eliminare, lo cancello.
|
|
if ( m_Values[nMap][nDex][nInt].nCompo == nPart + 1) {
|
|
SetToModifyDexelBlocks( nMap, nDex, nInt) ;
|
|
m_Values[nMap][nDex].erase( m_Values[nMap][nDex].begin() + nInt) ;
|
|
-- nInt ;
|
|
}
|
|
else if ( m_Values[nMap][nDex][nInt].nCompo > nPart + 1)
|
|
m_Values[nMap][nDex][nInt].nCompo -= 1 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Decremento il numero di componenti.
|
|
m_nConnectedCompoCount -= 1 ;
|
|
|
|
// Imposto ricalcolo grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
VolZmap::GetPartMinDistFromPoint( const Point3d& ptP) const
|
|
{
|
|
// Verifico lo stato e che siano definibili le componenti connesse
|
|
if ( m_nStatus != OK || m_nMapNum == 1)
|
|
return - 1 ;
|
|
// Se il numero di componenti è indefinito, lo ricalcolo
|
|
if ( m_nConnectedCompoCount == -1)
|
|
const_cast<VolZmap*>( this)->CheckMapConnection() ;
|
|
// Se non vi sono componenti, abbiamo finito
|
|
if ( m_nConnectedCompoCount == 0)
|
|
return - 1 ;
|
|
// Porto il punto nel riferimento intrinseco
|
|
Point3d ptPL = ptP ;
|
|
ptPL.ToLoc( m_MapFrame) ;
|
|
// Trovo la componente connessa di minima distanza dal punto
|
|
double dMinDist = DBL_MAX ;
|
|
int nMinDistPart = - 1 ;
|
|
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
|
|
for ( int nDex = 0 ; nDex < m_nDim[nMap] ; ++ nDex) {
|
|
double dX = ( ( nDex % m_nNx[nMap]) + 0.5) * m_dStep ;
|
|
double dY = ( ( nDex / m_nNx[nMap]) + 0.5) * m_dStep ;
|
|
int nIntervalNum = int( m_Values[nMap][nDex].size()) ;
|
|
for ( int nInt = 0 ; nInt < nIntervalNum ; ++ nInt) {
|
|
Point3d ptSt( dX, dY, m_Values[nMap][nDex][nInt].dMin) ;
|
|
Point3d ptEn( dX, dY, m_Values[nMap][nDex][nInt].dMax) ;
|
|
// Riporto le coordinate cicliche delle normali nell'ordine di partenza (da griglia a sistema intrinseco)
|
|
if ( nMap == 1) {
|
|
swap( ptSt.x, ptSt.z) ;
|
|
swap( ptSt.y, ptSt.z) ;
|
|
swap( ptEn.x, ptEn.z) ;
|
|
swap( ptEn.y, ptEn.z) ;
|
|
}
|
|
else if ( nMap == 2) {
|
|
swap( ptSt.y, ptSt.z) ;
|
|
swap( ptSt.x, ptSt.z) ;
|
|
swap( ptEn.y, ptEn.z) ;
|
|
swap( ptEn.x, ptEn.z) ;
|
|
}
|
|
// Calcolo la distanza del punto dal segmento corrente. Se è minore della minima distanza aggiorno quest'ultima
|
|
// e la corrispondente componente connessa di minima distanza con la distanza e la componente connessa correnti.
|
|
double dDist ;
|
|
DistPointLine DistCalc( ptPL, ptSt, ptEn) ;
|
|
if ( DistCalc.GetDist( dDist) && dDist < dMinDist) {
|
|
dMinDist = dDist ;
|
|
nMinDistPart = m_Values[nMap][nDex][nInt].nCompo ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ( nMinDistPart - 1) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::AddSurfTm( const ISurfTriMesh* pStm)
|
|
{
|
|
// controllo sulla superficie
|
|
double dVol ;
|
|
if ( pStm == nullptr || ! pStm->IsValid() || ! pStm->IsClosed() ||
|
|
! pStm->GetVolume( dVol) || dVol < 0)
|
|
return false ;
|
|
|
|
// controllo se il Box3d della superficie si interseca con il Box3d dello Zmap corrente
|
|
BBox3d BBox_stm, BBox_curr ;
|
|
if ( ! pStm->GetLocalBBox( BBox_stm) || ! GetLocalBBox( BBox_curr))
|
|
return false ;
|
|
BBox3d BBox_inters ;
|
|
if ( BBox_stm.FindIntersection( BBox_curr, BBox_inters) && BBox_inters.IsEmpty())
|
|
return true ; // se non ci sono intersezioni, la superficie non influenza lo Zmap
|
|
Vector3d vtLen = BBox_curr.GetMax() - BBox_curr.GetMin() ; // dimensione massima dello spillone
|
|
|
|
// ciclo sulle griglie
|
|
bool bCompleted = true ;
|
|
for ( int nG = 0 ; nG < m_nMapNum ; ++ nG) {
|
|
// definisco dei sistemi di riferimento ausiliari
|
|
Frame3d frMapFrame ;
|
|
if ( nG == 0)
|
|
frMapFrame = m_MapFrame ;
|
|
else if ( nG == 1)
|
|
frMapFrame.Set( m_MapFrame.Orig(), Y_AX, Z_AX, X_AX) ;
|
|
else if ( nG == 2)
|
|
frMapFrame.Set( m_MapFrame.Orig(), Z_AX, X_AX, Y_AX) ;
|
|
|
|
// oggetto per calcolo massivo intersezioni
|
|
IntersParLinesSurfTm intPLSTM( frMapFrame, *pStm) ;
|
|
|
|
// numero massimo di thread
|
|
int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
|
|
vector<future<bool>> vRes ;
|
|
vRes.resize( nThreadMax) ;
|
|
// se dimensione griglia in X maggiore di dimensione Y
|
|
if ( m_nNx[nG] > m_nNy[nG]) {
|
|
int nDexNum = m_nNx[nG] / nThreadMax ;
|
|
int nRemainder = m_nNx[nG] % nThreadMax ;
|
|
int nInfI = 0 ;
|
|
int nSupI = 0 ;
|
|
// aggiungo le parti interessate alla mappa
|
|
for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
|
|
nInfI = nSupI ;
|
|
nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
|
|
vRes[nThread] = async( launch::async, &VolZmap::AddMapPart, this, nG,
|
|
nInfI, nSupI, 0, m_nNy[nG], ref( vtLen), ref( m_MapFrame.Orig()),
|
|
ref( *pStm), ref( intPLSTM)) ;
|
|
}
|
|
}
|
|
// se dimensione griglia in Y maggiore di dimensione X
|
|
else {
|
|
int nDexNum = m_nNy[nG] / nThreadMax ;
|
|
int nRemainder = m_nNy[nG] % nThreadMax ;
|
|
int nInfJ = 0 ;
|
|
int nSupJ = 0 ;
|
|
// aggiungo le parti interessate alla mappa
|
|
for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
|
|
nInfJ = nSupJ ;
|
|
nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
|
|
vRes[nThread] = async( launch::async, &VolZmap::AddMapPart, this, nG,
|
|
0, m_nNx[nG], nInfJ, nSupJ, ref( vtLen), ref( m_MapFrame.Orig()),
|
|
ref( *pStm), ref( intPLSTM)) ;
|
|
}
|
|
}
|
|
|
|
// ciclo per attendere che tutti gli async abbiano terminato.
|
|
int nTerminated = 0 ;
|
|
while ( nTerminated < nThreadMax) {
|
|
for ( int nL = 0 ; nL < nThreadMax ; ++ nL) {
|
|
// async terminato
|
|
if ( vRes[nL].valid() && vRes[nL].wait_for( chrono::microseconds{ 1}) == future_status::ready) {
|
|
++ nTerminated ;
|
|
bCompleted = bCompleted && vRes[nL].get() ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ! bCompleted)
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SubtractSurfTm( const ISurfTriMesh* pStm)
|
|
{
|
|
// controllo sulla superficie
|
|
double dVol ;
|
|
if ( pStm == nullptr || ! pStm->IsValid() || ! pStm->IsClosed() ||
|
|
! pStm->GetVolume( dVol) || dVol < 0)
|
|
return false ;
|
|
|
|
// controllo se il Box3d della superficie si interseca con il Box3d dello Zmap corrente
|
|
BBox3d BBox_stm, BBox_curr ;
|
|
if ( ! pStm->GetLocalBBox( BBox_stm) || ! GetLocalBBox( BBox_curr))
|
|
return false ;
|
|
BBox3d BBox_inters ;
|
|
if ( BBox_stm.FindIntersection( BBox_curr, BBox_inters) && BBox_inters.IsEmpty())
|
|
return true ; // se non ci sono intersezioni, la superficie non influenza lo Zmap
|
|
Vector3d vtLen = BBox_curr.GetMax() - BBox_curr.GetMin() ; // dimensione massima dello spillone
|
|
|
|
// ciclo sulle griglie
|
|
bool bCompleted = true ;
|
|
for ( int nG = 0 ; nG < m_nMapNum ; ++ nG) {
|
|
// definisco dei sistemi di riferimento ausiliari
|
|
Frame3d frMapFrame ;
|
|
if ( nG == 0)
|
|
frMapFrame = m_MapFrame ;
|
|
else if ( nG == 1)
|
|
frMapFrame.Set( m_MapFrame.Orig(), Y_AX, Z_AX, X_AX) ;
|
|
else if ( nG == 2)
|
|
frMapFrame.Set( m_MapFrame.Orig(), Z_AX, X_AX, Y_AX) ;
|
|
|
|
// oggetto per calcolo massivo intersezioni
|
|
IntersParLinesSurfTm intPLSTM( frMapFrame, *pStm) ;
|
|
|
|
// numero massimo di thread
|
|
int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
|
|
vector<future<bool>> vRes ;
|
|
vRes.resize( nThreadMax) ;
|
|
// se dimensione griglia in X maggiore di dimensione Y
|
|
if ( m_nNx[nG] > m_nNy[nG]) {
|
|
int nDexNum = m_nNx[nG] / nThreadMax ;
|
|
int nRemainder = m_nNx[nG] % nThreadMax ;
|
|
int nInfI = 0 ;
|
|
int nSupI = 0 ;
|
|
// aggiungo le parti interessate alla mappa
|
|
for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
|
|
nInfI = nSupI ;
|
|
nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
|
|
vRes[nThread] = async( launch::async, &VolZmap::SubtractMapPart, this, nG,
|
|
nInfI, nSupI, 0, m_nNy[nG], ref( vtLen), ref( m_MapFrame.Orig()),
|
|
ref( *pStm), ref( intPLSTM)) ;
|
|
}
|
|
}
|
|
// se dimensione griglia in Y maggiore di dimensione X
|
|
else {
|
|
int nDexNum = m_nNy[nG] / nThreadMax ;
|
|
int nRemainder = m_nNy[nG] % nThreadMax ;
|
|
int nInfJ = 0 ;
|
|
int nSupJ = 0 ;
|
|
// aggiungo le parti interessate alla mappa
|
|
for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
|
|
nInfJ = nSupJ ;
|
|
nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
|
|
vRes[nThread] = async( launch::async, &VolZmap::SubtractMapPart, this, nG,
|
|
0, m_nNx[nG], nInfJ, nSupJ, ref( vtLen), ref( m_MapFrame.Orig()),
|
|
ref( *pStm), ref( intPLSTM)) ;
|
|
}
|
|
}
|
|
|
|
// ciclo per attendere che tutti gli async abbiano terminato.
|
|
int nTerminated = 0 ;
|
|
while ( nTerminated < nThreadMax) {
|
|
for ( int nL = 0 ; nL < nThreadMax ; ++ nL) {
|
|
// async terminato
|
|
if ( vRes[nL].valid() && vRes[nL].wait_for( chrono::microseconds{ 1}) == future_status::ready) {
|
|
++ nTerminated ;
|
|
bCompleted = bCompleted && vRes[nL].get() ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ! bCompleted)
|
|
return false ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::MakeUniform( double dToler, bool bIsExtensionFirst, int nToolNum)
|
|
{
|
|
// Controllo validità dello Zmap
|
|
if ( ! IsValid())
|
|
return false ;
|
|
|
|
// Creo lo ZMap per i riferimenti degli intervalli sulle griglie
|
|
PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
|
|
if ( IsNull( pZMapCopy) || ! pZMapCopy->IsValid())
|
|
return false ;
|
|
|
|
// Creo uno ZMap per gli intervalli da aggiungere o da rimuovere
|
|
PtrOwner<VolZmap> pZMapExtra( CreateBasicVolZmap()) ;
|
|
if ( IsNull( pZMapExtra) ||
|
|
! pZMapExtra->CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1], m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
|
|
m_dStep, IsTriDexel()))
|
|
return false ;
|
|
|
|
// Dovendo effettuare estensioni, allargo gli ingobri nelle direzioni principali
|
|
m_dMinZ[0] -= dToler ;
|
|
m_dMinZ[1] -= dToler ;
|
|
m_dMinZ[2] -= dToler ;
|
|
m_dMaxZ[0] += dToler ;
|
|
m_dMaxZ[1] += dToler ;
|
|
m_dMaxZ[2] += dToler ;
|
|
|
|
// NB. Tutti i parametri sono sempre presi dalla Copia dello ZMap corrente
|
|
// Ciclo sulle griglie
|
|
for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
|
|
// Ciclo sul numero di dexel presenti nella Copia
|
|
for ( int nDex = 0 ; nDex < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
|
|
// Se il dexel corrente non ha sotto-intervalli passo al successivo
|
|
if ( pZMapCopy->m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nGrid] ;
|
|
int nJ = nDex / m_nNx[nGrid] ;
|
|
// Recupero il numero di intervalli presenti nel Dexel corrente
|
|
int nIntervals = ssize( pZMapCopy->m_Values[nGrid][nDex]) ;
|
|
// Scorro gli intervalli presenti
|
|
for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
// Recupero l'intervallo corrente
|
|
Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
|
|
// --- Se richiesta prima estensione
|
|
if ( bIsExtensionFirst) {
|
|
// *** Estremo inferiore -> Intervallo : [ dMin - dToler, dMin + dToler ]
|
|
// Aggiungo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
|
|
AddIntervals( nGrid, nI, nJ, Interval.dMin - dToler, Interval.dMin + dToler,
|
|
Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
|
|
// Se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due direzioni
|
|
if ( IsTriDexel() && nIntervals != ssize( m_Values[nGrid][nDex])) {
|
|
// Aggiorno gli intervalli correnti ( dato che il corrente si è unito al precedente)
|
|
// ( lascio invariato lo ZMapCopy)
|
|
nIntervals = ssize( m_Values[nGrid][nDex]) ;
|
|
pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
|
|
pZMapCopy->m_Values[nGrid][nDex][nInfo-1].dMax, Interval.dMin,
|
|
dToler, true, nToolNum, V_INVALID, V_INVALID) ;
|
|
}
|
|
// *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax + dToler ]
|
|
// Aggiungo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
|
|
AddIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + dToler,
|
|
Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
|
|
// Se si sono uniti degli intervalli, potrei dover aggiungere degli spilloni nelle altre due direzioni
|
|
if ( IsTriDexel() && nIntervals != ssize( m_Values[nGrid][nDex])) {
|
|
// Aggiorno gli intervalli correnti ( dato che il corrente si è unito al successivo)
|
|
// ( lascio invariato lo ZMapCopy)
|
|
nIntervals = ssize( m_Values[nGrid][nDex]) ;
|
|
pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
|
|
Interval.dMax, pZMapCopy->m_Values[nGrid][nDex][nInfo+1].dMin,
|
|
dToler, true, nToolNum, V_INVALID, V_INVALID) ;
|
|
}
|
|
}
|
|
// --- Se richiesta prima restrizione
|
|
else {
|
|
// Se la lunghezza dell'intervallo non è almeno il doppio della tolleranza
|
|
double dLen = Interval.dMax - Interval.dMin ;
|
|
if ( dLen < 2. * ( dToler + EPS_SMALL)) {
|
|
// L'intervallo sparisce completamente
|
|
SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
|
|
Interval.vtMinN, Interval.vtMaxN, nToolNum, true) ;
|
|
// Rimuovo le parti di spillone nelle altre dimensioni
|
|
if ( IsTriDexel()) {
|
|
-- nIntervals ;
|
|
pZMapExtra->UniformIntervalsInVoxel( nGrid, nI, nJ,
|
|
Interval.dMin, Interval.dMax,
|
|
dToler, true, Tool::UNDEF, V_INVALID, V_INVALID) ;
|
|
}
|
|
}
|
|
// Se sufficientemente lungo, allora
|
|
else {
|
|
// *** Estremo inferiore -> Intervallo : [ dMin, dMin + dToler ]
|
|
// Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
|
|
SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMin + dToler,
|
|
Interval.vtMinN, Interval.vtMinN, nToolNum, true) ;
|
|
// *** Estremo superiore -> Intervallo : [ dMax - dToler, dMax ]
|
|
// Sottraggo l'intervallo nello Zmap corrente ( lascio invariato lo ZMapCopy)
|
|
SubtractIntervals( nGrid, nI, nJ, Interval.dMax - dToler, Interval.dMax + EPS_SMALL,
|
|
Interval.vtMaxN, Interval.vtMaxN, nToolNum, true) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ciclo sulle griglie ( uso lo Zmap Corrente, lascio invariato pZMapCopy)
|
|
for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
|
|
// Ciclo sul numero di dexel presenti
|
|
for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
|
|
// Se l'intervallo è vuoto, non faccio nulla
|
|
if ( m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Per ogni intervallo ricavato fino ad ora, restringo della tolleranza
|
|
for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
// --- Se richiesta prima estensione
|
|
if ( bIsExtensionFirst) {
|
|
m_Values[nGrid][nDex][nInfo].dMin += dToler ;
|
|
m_Values[nGrid][nDex][nInfo].dMax -= dToler ;
|
|
}
|
|
// --- Se richiesta prima restrizione
|
|
else {
|
|
m_Values[nGrid][nDex][nInfo].dMin -= dToler ;
|
|
m_Values[nGrid][nDex][nInfo].dMax += dToler ;
|
|
}
|
|
// Definisco il colore
|
|
for ( int nOrigInfo = 0 ; nOrigInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nOrigInfo) {
|
|
if ( pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].dMin - m_Values[nGrid][nDex][nInfo].dMin < EPS_SMALL)
|
|
m_Values[nGrid][nDex][nInfo].nToolMin = pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].nToolMin ;
|
|
if ( pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].dMax - m_Values[nGrid][nDex][nInfo].dMax < EPS_SMALL)
|
|
m_Values[nGrid][nDex][nInfo].nToolMax = pZMapCopy->m_Values[nGrid][nDex][nOrigInfo].nToolMax ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Gestisco le parti Extra ricavate
|
|
// Ciclo sulle griglie ( uso lo ZmapExtra, lascio invariato pZMapCopy)
|
|
for ( int nGrid = 0 ; nGrid < pZMapExtra->m_nMapNum ; ++ nGrid) {
|
|
// Ciclo sul numero di dexel presenti
|
|
for ( int nDex = 0 ; nDex < ssize( pZMapExtra->m_Values[nGrid]) ; ++ nDex) {
|
|
// Se l'intervallo è vuoto, non faccio nulla
|
|
if ( pZMapExtra->m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nGrid] ;
|
|
int nJ = nDex / m_nNx[nGrid] ;
|
|
// Per ogni intervallo ricavato fino ad ora...
|
|
for ( int nInfo = 0 ; nInfo < ssize( pZMapExtra->m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
double dMin = pZMapExtra->m_Values[nGrid][nDex][nInfo].dMin ;
|
|
double dMax = pZMapExtra->m_Values[nGrid][nDex][nInfo].dMax ;
|
|
Vector3d vtNMin = pZMapExtra->m_Values[nGrid][nDex][nInfo].vtMinN ;
|
|
Vector3d vtNMax = pZMapExtra->m_Values[nGrid][nDex][nInfo].vtMaxN ;
|
|
// --- Se richiesta prima estensione
|
|
if ( bIsExtensionFirst) {
|
|
// Aggiungo i contributi
|
|
AddIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
|
|
}
|
|
// --- Se richiesta prima restrizione
|
|
else {
|
|
// Sottraggo i contributi
|
|
SubtractIntervals( nGrid, nI, nJ, dMin, dMax, vtNMin, vtNMax, nToolNum, true) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Restringo gli ingombri espensi in precedenza
|
|
m_dMinZ[0] += dToler ;
|
|
m_dMinZ[1] += dToler ;
|
|
m_dMinZ[2] += dToler ;
|
|
m_dMaxZ[0] -= dToler ;
|
|
m_dMaxZ[1] -= dToler ;
|
|
m_dMaxZ[2] -= dToler ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::RemoveFins( const Vector3d& vtDir, double dThick)
|
|
{
|
|
// Verifico la Validità dello ZMap
|
|
if ( ! IsValid())
|
|
return false ;
|
|
|
|
// Per sicurezza normalizzo la direzione
|
|
Vector3d vtMyDir = vtDir ;
|
|
if ( ! vtMyDir.Normalize())
|
|
return false ;
|
|
double dMyThick = max( 10. * EPS_SMALL, dThick) ;
|
|
|
|
// Creo lo ZMap per i riferimenti degli intervalli sulle griglie
|
|
PtrOwner<VolZmap> pZMapCopy( CloneBasicVolZmap( this)) ;
|
|
if ( IsNull( pZMapCopy) || ! pZMapCopy->IsValid())
|
|
return false ;
|
|
|
|
// Creo uno ZMap per gli intervalli da aggiungere e successivamente da rimuovere
|
|
VolZmap ZMapExtra ;
|
|
if ( ! ZMapExtra.CreateEmpty( m_MapFrame.Orig(), m_dMaxZ[1] - m_dMinZ[1], m_dMaxZ[2] - m_dMinZ[2], m_dMaxZ[0] - m_dMinZ[0],
|
|
m_dStep, IsTriDexel()))
|
|
return false ;
|
|
|
|
const double FIN_ANG_DEG_TOL = 55. ; // Approssimazione per eccesso dell'angolo massimo possibile tra una direzione generica
|
|
// e un versore della terna globale ( arccos( 1 / sqrt( 3) ~ 54.375)
|
|
const double COS_FIN_ANG_DEG_TOL = cos( FIN_ANG_DEG_TOL * DEGTORAD) ;
|
|
const int NUM_TOOL = 1000 ; // Identificativo Utensile per riconoscere le parti rimosse
|
|
|
|
// NB. Tutti i parametri sono sempre presi dalla Copia dello ZMap corrente
|
|
// Ciclo sulle griglie
|
|
DBLVECTOR vdThicks ;
|
|
if ( IsTriDexel())
|
|
vdThicks = { dThick, dThick, dThick} ;
|
|
else
|
|
vdThicks = { dThick} ;
|
|
for ( int nGrid = 0 ; nGrid < pZMapCopy->m_nMapNum ; ++ nGrid) {
|
|
// Verifico se l'angolo tra la direzione degli spilloni della griglia corrente è sotto alla tolleranza rispetto alla direzione
|
|
double dCosDir = ( nGrid == 0 ? vtMyDir.z :
|
|
( nGrid == 1 ? vtMyDir.x :
|
|
vtMyDir.y)) ;
|
|
if ( abs( dCosDir) < COS_FIN_ANG_DEG_TOL + EPS_ANG_SMALL)
|
|
continue ;
|
|
// Aggiorno l'effettivo valore dello spessore da considerare
|
|
double dCurrThick = dMyThick / abs( dCosDir) ; // (sicuramente esiste, essendo 55deg il limite)
|
|
vdThicks[nGrid] = dCurrThick ;
|
|
// Ciclo sul numero di dexel presenti nella Copia
|
|
for ( int nDex = 0 ; nDex < ssize( pZMapCopy->m_Values[nGrid]) ; ++ nDex) {
|
|
// Se il dexel corrente non ha sotto-intervalli passo al successivo
|
|
if ( pZMapCopy->m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nGrid] ;
|
|
int nJ = nDex / m_nNx[nGrid] ;
|
|
// Scorro gli intervalli presenti
|
|
for ( int nInfo = 0 ; nInfo < ssize( pZMapCopy->m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
// Recupero l'intervallo corrente
|
|
Data& Interval = pZMapCopy->m_Values[nGrid][nDex][nInfo] ;
|
|
// Se entrambi gli estremi dell'intervallo non sono stati toccati dall'utensile, allora passo al successivo
|
|
bool bAnalyze = ( ( Interval.nToolMin == 1 && Interval.nToolMax == 1) ||
|
|
( Interval.dMax > m_dMaxZ[nGrid] - EPS_SMALL || Interval.dMin < m_dMinZ[nGrid] + EPS_SMALL)) ;
|
|
if ( ! bAnalyze)
|
|
continue ;
|
|
// Se la lunghezza dell'intervallo è superiore allo spessore richiesto, non faccio nulla
|
|
double dLen = Interval.dMax - Interval.dMin ;
|
|
if ( dLen > dCurrThick + EPS_ZERO)
|
|
continue ;
|
|
// Se ZMap composto da una sola griglia, elimino il contributo lungo la direzione corrente
|
|
if ( ! IsTriDexel()) {
|
|
SubtractIntervals( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL,
|
|
- Interval.vtMinN, - Interval.vtMaxN, NUM_TOOL, true) ;
|
|
}
|
|
// Se Tridexel, aggiungo il contributo del cubetto corrente allo ZMap Extra
|
|
else
|
|
ZMapExtra.AddStripInterval( nGrid, nI, nJ, Interval.dMin - EPS_SMALL, Interval.dMax + EPS_SMALL, NUM_TOOL) ;
|
|
}
|
|
}
|
|
}
|
|
// Se non ho aggiunto alcun elemento allo ZMap Extra, non devo fare nulla
|
|
if ( ! ZMapExtra.IsValid())
|
|
return true ;
|
|
#if DEBUG_REMOVE_FINS
|
|
SaveGeoObj( ZMapExtra.Clone(), "C:\\Temp\\VolZMapSubt0.nge") ;
|
|
#endif
|
|
|
|
// Ciclo sulle griglie dello ZMap Extra
|
|
for ( int nGrid = 0 ; nGrid < ZMapExtra.m_nMapNum ; ++ nGrid) {
|
|
// Ciclo sul numero di dexel presenti
|
|
for ( int nDex = 0 ; nDex < ssize( ZMapExtra.m_Values[nGrid]) ; ++ nDex) {
|
|
// Se l'intervallo è vuoto, non faccio nulla
|
|
if ( ZMapExtra.m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nGrid] ;
|
|
int nJ = nDex / m_nNx[nGrid] ;
|
|
// Scorro i gli Intervalli dello Spillone corrente
|
|
for ( int nInfo = 0 ; nInfo < ssize( ZMapExtra.m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
double dMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMin ;
|
|
double dMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].dMax ;
|
|
Vector3d vtNMin = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMinN ;
|
|
Vector3d vtNMax = ZMapExtra.m_Values[nGrid][nDex][nInfo].vtMaxN ;
|
|
// sottraggo tali contributi
|
|
SubtractIntervals( nGrid, nI, nJ, dMin, dMax, - vtNMin, - vtNMax, NUM_TOOL, true) ;
|
|
}
|
|
}
|
|
}
|
|
if ( ! IsValid())
|
|
return true ;
|
|
#if DEBUG_REMOVE_FINS
|
|
SaveGeoObj( this->Clone(), "C:\\Temp\\VolZMapSubt1.nge") ;
|
|
#endif
|
|
|
|
// Sistemo le Normali sullo ZMap ricavato
|
|
for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
|
|
// Ciclo sul numero di dexel presenti
|
|
for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
|
|
// Se l'Intervallo è vuoto non faccio nulla
|
|
if ( m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nGrid] ;
|
|
int nJ = nDex / m_nNx[nGrid] ;
|
|
// Scorro gli intervalli dello spillone corrente
|
|
for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
// Se intervallo con estremo minimo derivante dalla sottrazione con ZMapExtra, medio le normali
|
|
int nToolMin = m_Values[nGrid][nDex][nInfo].nToolMin ;
|
|
if ( nToolMin == NUM_TOOL) {
|
|
// Recupero il valore minimo, se sul bordo dello ZMap corrente non faccio nulla
|
|
double dMin = m_Values[nGrid][nDex][nInfo].dMin ;
|
|
if ( dMin > m_dMinZ[nGrid] + EPS_SMALL) {
|
|
Vector3d vtMinN = V_NULL ;
|
|
double dZMin = INFINITO ;
|
|
if ( ! pZMapCopy->ComputePointAndNormalForRemovingFins( nGrid, nI, nJ, dMin, vtMyDir, dThick, true, 1, vtMinN, dZMin)) {
|
|
vtMinN = - ( nGrid == 0 ? m_MapFrame.VersZ() : nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY()) ;
|
|
dZMin = dMin ;
|
|
}
|
|
m_Values[nGrid][nDex][nInfo].vtMinN = vtMinN ;
|
|
m_Values[nGrid][nDex][nInfo].dMin = dZMin ;
|
|
}
|
|
}
|
|
// Se intervallo con estremo massimo derivante dalla sottrazione con ZMapExtra, medio le normali
|
|
int nToolMax = m_Values[nGrid][nDex][nInfo].nToolMax ;
|
|
if ( nToolMax == NUM_TOOL) {
|
|
// Recupero il valore massimo, se sul bordo dello ZMap corrente non faccio nulla
|
|
double dMax = m_Values[nGrid][nDex][nInfo].dMax ;
|
|
if ( dMax < m_dMaxZ[nGrid] - EPS_SMALL) {
|
|
Vector3d vtMaxN = V_NULL ;
|
|
double dZMax = INFINITO ;
|
|
if ( ! pZMapCopy->ComputePointAndNormalForRemovingFins( nGrid, nI, nJ, dMax, vtMyDir, dThick, false, 1, vtMaxN, dZMax)) {
|
|
vtMaxN = ( nGrid == 0 ? m_MapFrame.VersZ() : nGrid == 1 ? m_MapFrame.VersX() : m_MapFrame.VersY()) ;
|
|
dZMax = dMax ;
|
|
}
|
|
m_Values[nGrid][nDex][nInfo].vtMaxN = vtMaxN ;
|
|
m_Values[nGrid][nDex][nInfo].dMax = dZMax ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Riassegno il Tool dell'utensile alle nuove parti
|
|
for ( int nGrid = 0 ; nGrid < m_nMapNum ; ++ nGrid) {
|
|
// Ciclo sul numero di dexel presenti
|
|
for ( int nDex = 0 ; nDex < ssize( m_Values[nGrid]) ; ++ nDex) {
|
|
// Se l'Intervallo è vuoto non faccio nulla
|
|
if ( m_Values[nGrid][nDex].empty())
|
|
continue ;
|
|
// Scorro gli intervalli dello spillone corrente
|
|
for ( int nInfo = 0 ; nInfo < ssize( m_Values[nGrid][nDex]) ; ++ nInfo) {
|
|
if ( m_Values[nGrid][nDex][nInfo].nToolMin == NUM_TOOL)
|
|
m_Values[nGrid][nDex][nInfo].nToolMin = 1 ;
|
|
if ( m_Values[nGrid][nDex][nInfo].nToolMax == NUM_TOOL)
|
|
m_Values[nGrid][nDex][nInfo].nToolMax = 1 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetToModifyDexelBlocks( int nGrid, int nDex, int nInt)
|
|
{
|
|
// Controllo sulla validità della griglia
|
|
if ( nGrid < 0 || nGrid > 2)
|
|
return false ;
|
|
// Controllo sulla validità del dexel
|
|
if ( nDex <= - 1 || nDex >= int( m_Values[nGrid].size()))
|
|
return false ;
|
|
// Controllo sulla validità dell'intervallo
|
|
if ( nInt <= - 1 || nInt >= int( m_Values[nGrid][nDex].size()))
|
|
return false ;
|
|
|
|
// Determino quali blocchi sono stati modificati
|
|
int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ;
|
|
// Indici del dexel
|
|
int nI = nDex % m_nNx[nGrid] ;
|
|
int nJ = nDex / m_nNx[nGrid] ;
|
|
// Quote estreme del dexel
|
|
double dMin = m_Values[nGrid][nDex][nInt].dMin ;
|
|
double dMax = m_Values[nGrid][nDex][nInt].dMax ;
|
|
|
|
if ( nGrid == 0) {
|
|
|
|
int nXStop = 1 ;
|
|
int nYStop = 1 ;
|
|
|
|
int nXBlock[2] ;
|
|
int nYBlock[2] ;
|
|
|
|
// Passo dal dexel al voxel
|
|
nI /= m_nDexVoxRatio ;
|
|
nJ /= m_nDexVoxRatio ;
|
|
|
|
nXBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
|
|
nYBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
|
|
|
|
if ( nI % N_VOXBLOCK == 0 && nXBlock[0] > 0) {
|
|
nXBlock[1] = nXBlock[0] - 1 ;
|
|
++ nXStop ;
|
|
}
|
|
|
|
if ( nJ % N_VOXBLOCK == 0 && nYBlock[0] > 0) {
|
|
nYBlock[1] = nYBlock[0] - 1 ;
|
|
++ nYStop ;
|
|
}
|
|
|
|
// Numero di voxel lungo Z
|
|
int nVoxNumZ = int( m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
|
|
|
|
int nMinK = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumZ - 2) ;
|
|
int nMaxK = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumZ - 2) ;
|
|
|
|
int nMinZBlock = ( m_nMapNum == 1 ? 0 : Clamp( nMinK / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[2] - 1))) ;
|
|
int nMaxZBlock = min( int( m_nFracLin[2] - 1), nMaxK / int( m_nVoxNumPerBlock)) ;
|
|
|
|
for ( int tI = 0 ; tI < nXStop ; ++ tI) {
|
|
for ( int tJ = 0 ; tJ < nYStop ; ++ tJ) {
|
|
for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) {
|
|
int nBlockNum = k * nLayerBlock + nYBlock[tJ] * m_nFracLin[0] + nXBlock[tI] ;
|
|
m_BlockToUpdate[nBlockNum] = true ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
else if ( nGrid == 1) {
|
|
|
|
int nYStop = 1 ;
|
|
int nZStop = 1 ;
|
|
|
|
int nYBlock[2] ;
|
|
int nZBlock[2] ;
|
|
|
|
// Passo dal dexel al voxel
|
|
nI /= m_nDexVoxRatio ;
|
|
nJ /= m_nDexVoxRatio ;
|
|
|
|
nYBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[1] - 1) ;
|
|
nZBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
|
|
|
|
if ( nI % N_VOXBLOCK == 0 && nYBlock[0] > 0) {
|
|
nYBlock[1] = nYBlock[0] - 1 ;
|
|
++ nYStop ;
|
|
}
|
|
|
|
if ( nJ % N_VOXBLOCK == 0 && nZBlock[0] > 0) {
|
|
nZBlock[1] = nZBlock[0] - 1 ;
|
|
++ nZStop ;
|
|
}
|
|
|
|
// Numero di voxel lungo X
|
|
int nVoxNumX = int( m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
|
|
|
|
int nMinI = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumX - 2) ;
|
|
int nMaxI = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumX - 2) ;
|
|
|
|
int nMinXBlock = Clamp( nMinI / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[0] - 1)) ;
|
|
int nMaxXBlock = min( int( m_nFracLin[0] - 1), nMaxI / int( m_nVoxNumPerBlock)) ;
|
|
|
|
for ( int tI = 0 ; tI < nYStop ; ++ tI) {
|
|
for ( int tJ = 0 ; tJ < nZStop ; ++ tJ) {
|
|
for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) {
|
|
int nBlockNum = nZBlock[tJ] * nLayerBlock + nYBlock[tI] * m_nFracLin[0] + k ;
|
|
m_BlockToUpdate[nBlockNum] = true ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
else if ( nGrid == 2) {
|
|
|
|
int nXStop = 1 ;
|
|
int nZStop = 1 ;
|
|
|
|
int nXBlock[2] ;
|
|
int nZBlock[2] ;
|
|
|
|
// Passo dal dexel al voxel
|
|
nI /= m_nDexVoxRatio ;
|
|
nJ /= m_nDexVoxRatio ;
|
|
|
|
nXBlock[0] = min( nJ / m_nVoxNumPerBlock, m_nFracLin[0] - 1) ;
|
|
nZBlock[0] = min( nI / m_nVoxNumPerBlock, m_nFracLin[2] - 1) ;
|
|
|
|
if ( nJ % N_VOXBLOCK == 0 && nXBlock[0] > 0) {
|
|
nXBlock[1] = nXBlock[0] - 1 ;
|
|
++ nXStop ;
|
|
}
|
|
|
|
if ( nI % N_VOXBLOCK == 0 && nZBlock[0] > 0) {
|
|
nZBlock[1] = nZBlock[0] - 1 ;
|
|
++ nZStop ;
|
|
}
|
|
|
|
// Numero di voxel lungo Y
|
|
int nVoxNumY = int( m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2)) ;
|
|
|
|
int nMinJ = Clamp( int( floor( ( ( dMin - 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) - EPS_SMALL))), 0, nVoxNumY - 2) ;
|
|
int nMaxJ = Clamp( int( floor( ( ( dMax + 0.5 * m_dStep) / ( m_nDexVoxRatio * m_dStep) + EPS_SMALL))), 0, nVoxNumY - 2) ;
|
|
|
|
int nMinYBlock = Clamp( nMinJ / int( m_nVoxNumPerBlock), 0, int( m_nFracLin[1] - 1)) ;
|
|
int nMaxYBlock = min( int( m_nFracLin[1] - 1), nMaxJ / int( m_nVoxNumPerBlock)) ;
|
|
|
|
for ( int tI = 0 ; tI < nZStop ; ++ tI) {
|
|
for ( int tJ = 0 ; tJ < nXStop ; ++ tJ) {
|
|
for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) {
|
|
int nBlockNum = nZBlock[tI] * nLayerBlock + k * m_nFracLin[0] + nXBlock[tJ] ;
|
|
m_BlockToUpdate[nBlockNum] = true ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::IsMapPartABox( int nMap, int nInfI, int nSupI, int nInfJ, int nSupJ, double& dMinZ, double& dMaxZ)
|
|
{
|
|
dMinZ = m_dMaxZ[nMap] ;
|
|
dMaxZ = m_dMinZ[nMap] ;
|
|
for ( int i = nInfI ; i < nSupI ; ++ i) {
|
|
for ( int j = nInfJ ; j < nSupJ ; ++ j) {
|
|
int n = j * m_nNx[nMap] + i ;
|
|
int nSize = int( m_Values[nMap][n].size()) ;
|
|
if ( nSize > 1)
|
|
return false ;
|
|
else if ( nSize > 0) {
|
|
if ( dMinZ > dMaxZ) {
|
|
dMinZ = m_Values[nMap][n][0].dMin ;
|
|
dMaxZ = m_Values[nMap][n][0].dMax ;
|
|
}
|
|
else {
|
|
if ( abs( m_Values[nMap][n][0].dMin - dMinZ) > EPS_SMALL ||
|
|
abs( m_Values[nMap][n][0].dMax - dMaxZ) > EPS_SMALL)
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ( dMaxZ >= dMinZ) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::IsBox( void)
|
|
{
|
|
// Se non tridexel, non posso stabilire con il metodo seguente se è un box
|
|
// Verifico solo che gli spilloni di una mappa o sono nulli o hanno gli stessi estremi
|
|
if ( m_nMapNum == 1)
|
|
return false ;
|
|
// Numero massimo di thread per il calcolo parallelo.
|
|
int nThreadMax = max( 1, int( thread::hardware_concurrency()) - 1) ;
|
|
// Disponibile un solo thread
|
|
if ( nThreadMax == 1) {
|
|
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
|
|
double dMinZ, dMaxZ ;
|
|
if ( ! IsMapPartABox( nMap, 0, m_nNx[nMap], 0, m_nNy[nMap], dMinZ, dMaxZ)) {
|
|
m_bIsBox = false ;
|
|
return false ;
|
|
}
|
|
}
|
|
m_bIsBox = true ;
|
|
return true ;
|
|
}
|
|
|
|
// Caso di più thread
|
|
m_bIsBox = true ;
|
|
for ( int nMap = 0 ; nMap < m_nMapNum ; ++ nMap) {
|
|
vector< future<bool>> vRes ;
|
|
vRes.resize( nThreadMax) ;
|
|
std::vector<double> vMinZ, vMaxZ ;
|
|
vMinZ.resize( nThreadMax) ;
|
|
vMaxZ.resize( nThreadMax) ;
|
|
if ( m_nNx[nMap] > m_nNy[nMap]) {
|
|
int nDexNum = m_nNx[nMap] / nThreadMax ;
|
|
int nRemainder = m_nNx[nMap] % nThreadMax ;
|
|
int nInfI = 0 ;
|
|
int nSupI = 0 ;
|
|
for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
|
|
nInfI = nSupI ;
|
|
nSupI = nInfI + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
|
|
vRes[nThread] = async( launch::async, &VolZmap::IsMapPartABox, this, nMap,
|
|
nInfI, nSupI, 0, m_nNy[nMap], ref( vMinZ[nThread]), ref( vMaxZ[nThread])) ;
|
|
}
|
|
}
|
|
else {
|
|
int nDexNum = m_nNy[nMap] / nThreadMax ;
|
|
int nRemainder = m_nNy[nMap] % nThreadMax ;
|
|
int nInfJ = 0 ;
|
|
int nSupJ = 0 ;
|
|
for ( int nThread = 0 ; nThread < nThreadMax ; ++ nThread) {
|
|
nInfJ = nSupJ ;
|
|
nSupJ = nInfJ + ( nThread < nRemainder ? nDexNum + 1 : nDexNum) ;
|
|
vRes[nThread] = async( launch::async, &VolZmap::IsMapPartABox, this, nMap,
|
|
0, m_nNx[nMap], nInfJ, nSupJ, ref(vMinZ[nThread]), ref(vMaxZ[nThread])) ;
|
|
}
|
|
}
|
|
// Ciclo per attendere che tutti gli async abbiano terminato.
|
|
int nTerminated = 0 ;
|
|
while ( nTerminated < nThreadMax) {
|
|
for ( int nL = 0 ; nL < nThreadMax ; ++ nL) {
|
|
// Async terminato
|
|
if ( vRes[nL].valid() && vRes[nL].wait_for(chrono::microseconds{ 1 }) == future_status::ready) {
|
|
++ nTerminated ;
|
|
if ( ! vRes[nL].get()) {
|
|
m_bIsBox = false ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Se uno dei thread trova che la sua porzione non è un box, non lo può essere il solido intero.
|
|
if ( ! m_bIsBox)
|
|
return false ;
|
|
// Controllo che gli estremi Z siano uguali.
|
|
for ( int nT = 1 ; nT < nThreadMax ; ++ nT) {
|
|
if ( abs( vMinZ[nT] - vMinZ[0]) > EPS_SMALL ||
|
|
abs( vMaxZ[nT] - vMaxZ[0]) > EPS_SMALL) {
|
|
m_bIsBox = false ;
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_bIsBox ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Cut( const Plane3d& plPlane)
|
|
{
|
|
// Porto il piano nel riferimento intrinseco
|
|
Plane3d plMyPlane = plPlane ;
|
|
plMyPlane.ToLoc( m_MapFrame) ;
|
|
// Interseco lo Zmap col piano, ciclando sulle griglie
|
|
bool bModified = false ;
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
// Porto il piano nel riferimento di griglia
|
|
if ( nMap == 1) {
|
|
Frame3d frGrid ; frGrid.Set( ORIG, Y_AX, Z_AX, X_AX) ;
|
|
plMyPlane.ToLoc( frGrid) ;
|
|
}
|
|
else if (nMap == 2) {
|
|
Frame3d frGrid ; frGrid.Set( ORIG, Y_AX, Z_AX, X_AX) ;
|
|
plMyPlane.ToLoc( frGrid) ;
|
|
}
|
|
// Ciclo sui dexel della mappa
|
|
for ( int nD = 0 ; nD < int( m_Values[nMap].size()) ; ++ nD) {
|
|
// Se spillone già vuoto, passo al successivo
|
|
if ( m_Values[nMap][nD].empty())
|
|
continue ;
|
|
// Indici di spillone
|
|
int nI = nD % m_nNx[nMap] ;
|
|
int nJ = nD / m_nNx[nMap] ;
|
|
// Recupero estremi spillone
|
|
double dMin = m_Values[nMap][nD][0].dMin ;
|
|
double dMax = m_Values[nMap][nD][m_Values[nMap][nD].size() - 1].dMax ;
|
|
Point3d ptSt( ( nI + 0.5) * m_dStep, ( nJ + 0.5) * m_dStep, dMin) ;
|
|
Point3d ptEn( ( nI + 0.5) * m_dStep, ( nJ + 0.5) * m_dStep, dMax) ;
|
|
// Distanze degli estremi del segmento dal piano
|
|
double dStDist = DistPointPlane( ptSt, plMyPlane) ;
|
|
double dEnDist = DistPointPlane( ptEn, plMyPlane) ;
|
|
// Se entrambi sotto il piano
|
|
if ( dStDist < EPS_SMALL && dEnDist < EPS_SMALL)
|
|
// Non devo fare alcunché
|
|
;
|
|
// se altrimenti entrambi gli estremi sono oltre il piano
|
|
else if ( dStDist > -EPS_SMALL && dEnDist > -EPS_SMALL) {
|
|
// Si elimina tutto
|
|
SubtractIntervals( nMap, nI, nJ, dMin, dMax, V_NULL, V_NULL, 1) ;
|
|
}
|
|
// se altrimenti è da tenere il punto iniziale
|
|
else if ( dStDist < 0) {
|
|
// Si elimina la parte tra intersezione e punto finale
|
|
double dInt = dMin + ( dMax - dMin) * abs( dStDist) / ( abs( dStDist) + abs( dEnDist)) ;
|
|
SubtractIntervals( nMap, nI, nJ, dInt, dMax, plMyPlane.GetVersN(), V_NULL, 1) ;
|
|
}
|
|
// se altrimenti è da tenere il punto finale
|
|
else if (dEnDist < 0) {
|
|
// Si elimina la parte tra punto iniziale e intersezione
|
|
double dInt = dMin + ( dMax - dMin) * abs( dStDist) / ( abs( dStDist) + abs( dEnDist)) ;
|
|
SubtractIntervals( nMap, nI, nJ, dMin, dInt, V_NULL, plMyPlane.GetVersN(), 1) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bModified == true) {
|
|
// Imposto forma generica
|
|
m_nShape = GENERIC ;
|
|
// Imposto ricalcolo grafica
|
|
m_OGrMgr.Reset() ;
|
|
// Imposto numero di componenti connesse da ricalcolare
|
|
m_nConnectedCompoCount = - 1 ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Compact( void)
|
|
{
|
|
// Determino i nuovi estremi sugli indici e sulle quote Z e copio i dexel i cui indici sono compresi fra gli estremi
|
|
int nMinI[N_MAPS] ;
|
|
int nMinJ[N_MAPS] ;
|
|
int nMaxI[N_MAPS] ;
|
|
int nMaxJ[N_MAPS] ;
|
|
int nNx[N_MAPS] ;
|
|
int nNy[N_MAPS] ;
|
|
int nDim[N_MAPS] ;
|
|
double dMinZ[N_MAPS] ;
|
|
double dMaxZ[N_MAPS] ;
|
|
vector<vector<Data>> Values[N_MAPS] ;
|
|
bool bNotEmptyGrid = true ;
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
nMinI[nMap] = m_nNx[nMap] - 1 ;
|
|
nMinJ[nMap] = m_nNy[nMap] - 1 ;
|
|
nMaxI[nMap] = 0 ;
|
|
nMaxJ[nMap] = 0 ;
|
|
dMinZ[nMap] = m_dMaxZ[nMap] ;
|
|
dMaxZ[nMap] = m_dMinZ[nMap] ;
|
|
// Determino estremi degli indici e delle quote Z
|
|
for ( int nD = 0 ; nD < int( m_Values[nMap].size()) ; ++ nD) {
|
|
int nDexDim = int( m_Values[nMap][nD].size()) ;
|
|
if ( nDexDim > 0) {
|
|
int nI = nD % m_nNx[nMap] ;
|
|
int nJ = nD / m_nNx[nMap] ;
|
|
if ( nI < nMinI[nMap])
|
|
nMinI[nMap] = nI ;
|
|
if ( nJ < nMinJ[nMap])
|
|
nMinJ[nMap] = nJ ;
|
|
if ( nI > nMaxI[nMap])
|
|
nMaxI[nMap] = nI ;
|
|
if ( nJ > nMaxJ[nMap])
|
|
nMaxJ[nMap] = nJ ;
|
|
if ( m_Values[nMap][nD][0].dMin < dMinZ[nMap])
|
|
dMinZ[nMap] = m_Values[nMap][nD][0].dMin ;
|
|
if ( m_Values[nMap][nD][nDexDim - 1].dMax > dMaxZ[nMap])
|
|
dMaxZ[nMap] = m_Values[nMap][nD][nDexDim - 1].dMax ;
|
|
}
|
|
}
|
|
if ( nMinI[nMap] > nMaxI[nMap] || nMinJ[nMap] > nMaxJ[nMap]) {
|
|
bNotEmptyGrid = false ;
|
|
break ;
|
|
}
|
|
// Se necessario espando la griglia
|
|
if ( nMinI[nMap] > 0)
|
|
-- nMinI[nMap] ;
|
|
if ( nMinJ[nMap] > 0)
|
|
-- nMinJ[nMap] ;
|
|
if ( nMaxI[nMap] < int( m_nNx[nMap]) - 1)
|
|
++ nMaxI[nMap] ;
|
|
if ( nMaxJ[nMap] < int( m_nNy[nMap]) - 1)
|
|
++ nMaxJ[nMap] ;
|
|
nNx[nMap] = nMaxI[nMap] - nMinI[nMap] + 1 ;
|
|
nNy[nMap] = nMaxJ[nMap] - nMinJ[nMap] + 1 ;
|
|
nDim[nMap] = nNx[nMap] * nNy[nMap] ;
|
|
// Copio i dexel i cui indici sono compresi fra gli estremi
|
|
for ( int nD = 0 ; nD < int( m_Values[nMap].size()) ; ++ nD) {
|
|
int nI = nD % m_nNx[nMap] ;
|
|
int nJ = nD / m_nNx[nMap] ;
|
|
if ( nI >= nMinI[nMap] && nI <= nMaxI[nMap] && nJ >= nMinJ[nMap] && nJ <= nMaxJ[nMap]) {
|
|
Values[nMap].emplace_back( m_Values[nMap][nD]) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Se non vi è materiale
|
|
if ( ! bNotEmptyGrid) {
|
|
m_nStatus = TO_VERIFY ;
|
|
m_nNumBlock = 0 ;
|
|
m_nConnectedCompoCount = 0 ;
|
|
m_nShape = GENERIC ;
|
|
for ( int i = 0 ; i < N_MAPS ; ++ i) {
|
|
m_nNx[i] = 0 ;
|
|
m_nNy[i] = 0 ;
|
|
m_nDim[i] = 0 ;
|
|
m_dMinZ[i] = 0 ;
|
|
m_dMaxZ[i] = 0 ;
|
|
m_nFracLin[i] = 0 ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
// Coordinate x,y dell'origine del sistema di riferimento
|
|
double dNewOx = nMinI[0] * m_dStep ;
|
|
double dNewOy = nMinJ[0] * m_dStep ;
|
|
double dNewOz = nMinJ[1] * m_dStep ;
|
|
|
|
// Porto i dexel nel nuovo sistema di riferimento e le quote estreme Z. Non c'è bisogno di trasformare le normali,
|
|
// infatti i sistemi di riferimento in gioco differiscono al più per una traslazione.
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
// Quote estreme Z
|
|
switch ( nMap) {
|
|
case 0 :
|
|
dMinZ[nMap] -= dNewOz ;
|
|
dMaxZ[nMap] -= dNewOz ;
|
|
break ;
|
|
case 1 :
|
|
dMinZ[nMap] -= dNewOx ;
|
|
dMaxZ[nMap] -= dNewOx ;
|
|
break ;
|
|
case 2 :
|
|
dMinZ[nMap] -= dNewOy ;
|
|
dMaxZ[nMap] -= dNewOy ;
|
|
break ;
|
|
}
|
|
// Dexel
|
|
for ( int nD = 0 ; nD < int( nDim[nMap]) ; ++ nD) {
|
|
for ( int nS = 0 ; nS < int( Values[nMap][nD].size()) ; ++ nS) {
|
|
switch ( nMap) {
|
|
case 0 :
|
|
Values[nMap][nD][nS].dMin -= dNewOz ;
|
|
Values[nMap][nD][nS].dMax -= dNewOz ;
|
|
break ;
|
|
case 1 :
|
|
Values[nMap][nD][nS].dMin -= dNewOx ;
|
|
Values[nMap][nD][nS].dMax -= dNewOx ;
|
|
break ;
|
|
case 2 :
|
|
Values[nMap][nD][nS].dMin -= dNewOy ;
|
|
Values[nMap][nD][nS].dMax -= dNewOy ;
|
|
break ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Ricopio i dexel con gli indici compresi fra gli estremi
|
|
for ( int nMap = 0 ; nMap < int( m_nMapNum) ; ++ nMap) {
|
|
m_nNx[nMap] = nNx[nMap] ;
|
|
m_nNy[nMap] = nNy[nMap] ;
|
|
m_nDim[nMap] = nDim[nMap] ;
|
|
m_Values[nMap].resize( 0) ;
|
|
for ( int nD = 0 ; nD < int( Values[nMap].size()) ; ++ nD) {
|
|
m_Values[nMap].emplace_back( Values[nMap][nD]) ;
|
|
}
|
|
}
|
|
|
|
// Definisco il numero di blocchi lungo x,y e z
|
|
if ( ! CalcBlockNum())
|
|
return false ;
|
|
|
|
// Sistema di riferimento intrinseco del nuovo solido
|
|
Point3d ptNewO = m_MapFrame.Orig() + Vector3d( dNewOx, dNewOy, dNewOz) ;
|
|
m_MapFrame.Set( ptNewO, X_AX, Y_AX, Z_AX) ;
|
|
|
|
// Imposto ricalcolo grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ChangeResolution( int nDexVoxRatio)
|
|
{
|
|
if ( nDexVoxRatio < 1 || nDexVoxRatio > 5)
|
|
return false ;
|
|
if ( nDexVoxRatio != m_nDexVoxRatio) {
|
|
int nOldDexVoxRatio = m_nDexVoxRatio ;
|
|
m_nDexVoxRatio = nDexVoxRatio ;
|
|
if ( CalcBlockNum()) {
|
|
ResetGraphics() ;
|
|
m_OGrMgr.Clear() ;
|
|
return true ;
|
|
}
|
|
m_nDexVoxRatio = nOldDexVoxRatio ;
|
|
return false ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::CalcBlockNum( void)
|
|
{
|
|
// Calcolo il numero di voxel lungo X e Y
|
|
int nVoxNumX = m_nNx[0] / m_nDexVoxRatio + ( m_nNx[0] % m_nDexVoxRatio == 0 ? 1 : 2) ;
|
|
int nVoxNumY = m_nNy[0] / m_nDexVoxRatio + ( m_nNy[0] % m_nDexVoxRatio == 0 ? 1 : 2) ;
|
|
if ( nVoxNumX == 0 || nVoxNumY == 0)
|
|
return false ;
|
|
// Definisco il numero di blocchi lungo X e Y
|
|
m_nFracLin[0] = max( 1, nVoxNumX / m_nVoxNumPerBlock + ( nVoxNumX % m_nVoxNumPerBlock > m_nVoxNumPerBlock / 4 ? 1 : 0)) ;
|
|
m_nFracLin[1] = max( 1, nVoxNumY / m_nVoxNumPerBlock + ( nVoxNumY % m_nVoxNumPerBlock > m_nVoxNumPerBlock / 4 ? 1 : 0)) ;
|
|
if ( m_nMapNum == 1) {
|
|
m_nFracLin[2] = 1 ;
|
|
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
|
|
m_BlockToUpdate.clear() ;
|
|
m_BlockToUpdate.resize( m_nNumBlock, true) ;
|
|
m_BlockUpdatingCounter.clear() ;
|
|
m_BlockUpdatingCounter.resize( m_nNumBlock, 0) ;
|
|
m_SingleMapTria.resize( m_nNumBlock) ;
|
|
return true ;
|
|
}
|
|
// Calcolo il numero di voxel lungo Z
|
|
int nVoxNumZ = m_nNy[1] / m_nDexVoxRatio + ( m_nNy[1] % m_nDexVoxRatio == 0 ? 1 : 2) ;
|
|
// Definisco il numero di blocchi lungo Z
|
|
m_nFracLin[2] = max( 1, nVoxNumZ / m_nVoxNumPerBlock + ( nVoxNumZ % m_nVoxNumPerBlock > m_nVoxNumPerBlock / 4 ? 1 : 0)) ;
|
|
// Dimensiono e setto il vettore dei blocchi a da ricalcolare e il vettore di contatori di aggiornamenti della grafica
|
|
m_nNumBlock = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
|
|
m_BlockToUpdate.clear() ;
|
|
m_BlockToUpdate.resize( m_nNumBlock, true) ;
|
|
m_BlockUpdatingCounter.clear() ;
|
|
m_BlockUpdatingCounter.resize( m_nNumBlock + 1, 0) ;
|
|
|
|
// Dimensiono raccolta di voxel, triangoli di feature tra blocchi e di segnalatori di materiale fra voxel
|
|
m_InterBlockVox.resize( m_nNumBlock) ;
|
|
m_InterBlockOriginalSharpTria.resize( m_nNumBlock) ;
|
|
m_InterBlockSharpTria.resize( m_nNumBlock) ;
|
|
m_BlockSharpTria.resize( m_nNumBlock) ;
|
|
m_BlockSmoothTria.resize( m_nNumBlock) ;
|
|
m_BlockBigTria.resize( m_nNumBlock) ;
|
|
m_SingleMapTria.resize( m_nNumBlock) ;
|
|
m_SliceXY.resize( m_nNumBlock) ;
|
|
m_SliceXZ.resize( m_nNumBlock) ;
|
|
m_SliceYZ.resize( m_nNumBlock) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetToolTolerances( double dLinTol, double dAngTolDeg)
|
|
{
|
|
m_dToolLinTol = max( dLinTol, LIN_TOL_MIN) ;
|
|
m_dToolAngTolDeg = max( dAngTolDeg, ANG_TOL_MIN_DEG) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetStdTool( const string& sToolName, double dH, double dR, double dCornR, double dCutterH, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetStdTool( sToolName, dH, dR, dCornR, dCutterH, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetAdvTool( const string& sToolName,
|
|
double dH, double dR, double dTipH, double dTipR, double dCornR, double dCutterH, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetAdvTool( sToolName, dH, dR, dTipH, dTipR, dCornR, dCutterH, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetSawTool( const string& sToolName,
|
|
double dH, double dR, double dThick, double dStemR, double dCornR, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetSawTool( sToolName, dH, dR, dThick, dStemR, dCornR, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetGenTool( const string& sToolName, const ICurveComposite* pToolOutline, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetGenTool( sToolName, pToolOutline, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetMortiserTool( const string& sToolName, double dH, double dW, double dTh, double dRc, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetMortiserTool( sToolName, dH, dW, dTh, dRc, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetChiselTool( const string& sToolName, double dH, double dW, double dTh, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetChiselTool( sToolName, dH, dW, dTh, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetAdditiveTool( const std::string& sToolName,
|
|
double dH, double dR, double dRc, int nFlag, bool bFirst)
|
|
{
|
|
if ( bFirst) {
|
|
m_vTool.resize( 1) ;
|
|
m_vTool[0].Clear( true) ;
|
|
}
|
|
else
|
|
m_vTool.emplace_back( true) ;
|
|
m_nCurrTool = int( m_vTool.size()) - 1 ;
|
|
if ( m_nCurrTool < 0)
|
|
return false ;
|
|
m_vTool[m_nCurrTool].SetTolerances( m_dToolLinTol, m_dToolAngTolDeg) ;
|
|
return m_vTool[m_nCurrTool].SetAdditiveTool( sToolName, dH, dR, dRc, nFlag) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
VolZmap::GetToolCount( void) const
|
|
{
|
|
return m_vTool.size() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::SetCurrTool( int nCurrTool)
|
|
{
|
|
if ( nCurrTool < 0 || nCurrTool >= int( m_vTool.size()))
|
|
return false ;
|
|
m_nCurrTool = nCurrTool ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ResetTools( void)
|
|
{
|
|
m_vTool.resize( 1) ;
|
|
m_nCurrTool = 0 ;
|
|
return m_vTool[0].Clear() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const ICurveComposite&
|
|
VolZmap::GetToolOutline( bool bApprox) const
|
|
{
|
|
if ( m_nCurrTool < 0 || m_nCurrTool >= int( m_vTool.size())) {
|
|
static CurveComposite StatCrvCo ;
|
|
return StatCrvCo ;
|
|
}
|
|
const Tool& CurrTool = m_vTool[m_nCurrTool] ;
|
|
return ( bApprox ? CurrTool.GetApproxOutline() : CurrTool.GetOutline()) ;
|
|
}
|