Dario Sassi
398 lines
12 KiB
C++
398 lines
12 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2016
|
|
//----------------------------------------------------------------------------
|
|
// File : VolZmap.cpp Data : 22.01.15 Versione : 1.6a4
|
|
// Contenuto : Implementazione della classe Volume Zmap (singola griglia)
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 22.01.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "VolZmap.h"
|
|
#include "GeoObjFactory.h"
|
|
#include "NgeWriter.h"
|
|
#include "NgeReader.h"
|
|
#include "GeoConst.h"
|
|
#include "\EgtDev\Include\EGkIntervals.h"
|
|
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
VolZmap::VolZmap(void)
|
|
: m_nStatus( TO_VERIFY), m_nTempProp(), m_dLinTol( LIN_TOL_STD), m_dAngTolDeg( ANG_TOL_APPROX_DEG)
|
|
{
|
|
m_dStep = 0 ;
|
|
m_nNx = 0 ;
|
|
m_nNy = 0 ;
|
|
m_nDim = 0 ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
VolZmap::~VolZmap( void)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
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 = dynamic_cast<const VolZmap*>( pGObjSrc) ;
|
|
if ( pVzm == nullptr)
|
|
return false ;
|
|
return CopyFrom( *pVzm) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::CopyFrom( const VolZmap& vzmSrc)
|
|
{
|
|
if ( &vzmSrc == this)
|
|
return true ;
|
|
m_OGrMgr.Reset() ;
|
|
m_LocalFrame = vzmSrc.m_LocalFrame ;
|
|
m_dStep = vzmSrc.m_dStep ;
|
|
m_nDim = vzmSrc.m_nDim ;
|
|
m_nNx = vzmSrc.m_nNx ;
|
|
m_nNy = vzmSrc.m_nNy ;
|
|
m_ZValues = vzmSrc.m_ZValues ;
|
|
m_nStatus = vzmSrc.m_nStatus ;
|
|
m_nTempProp = vzmSrc.m_nTempProp ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeoObjType
|
|
VolZmap::GetType( void) const
|
|
{
|
|
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( VolZmap)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string&
|
|
VolZmap::GetTitle( void) const
|
|
{
|
|
static const string sTitle = "Zmap" ;
|
|
return sTitle ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Dump( string& sOut, bool bMM, const char* szNewLine) const
|
|
{
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
VolZmap::GetNgeId( void) const
|
|
{
|
|
return GEOOBJ_GETNGEID( VolZmap) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Save( NgeWriter& ngeOut) const
|
|
{
|
|
// parametri di scrittura: sistema di riferimento, minimo incremento, numero di passi
|
|
// in direzione x e y, e per ogni casella, numero di valori e valori
|
|
if ( ! ngeOut.WriteFrame( m_LocalFrame, ";", true))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_dStep, ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_nNx, ",", false))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_nNy, ";", true))
|
|
return false ;
|
|
// ciclo sui dexel
|
|
for ( unsigned int i = 0 ; i < m_nDim ; ++ i) {
|
|
// numero di estremi
|
|
int nDim = int( m_ZValues[i].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 ( unsigned int k = 0 ; k < m_ZValues[i].size() ; ++ k) {
|
|
bool bEndL = ( k == m_ZValues[i].size() - 1) ;
|
|
if ( ! ngeOut.WriteDouble( m_ZValues[i][k], ( bEndL ? ";" : ","), bEndL))
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Load( NgeReader& ngeIn)
|
|
{
|
|
m_nStatus = TO_VERIFY ;
|
|
// parametri di lettura: sistema di riferimento, minimo incremento, numero di passi
|
|
// in direzione x e y, e per ogni casella, numero di valori e valori
|
|
if ( ! ngeIn.ReadFrame( m_LocalFrame, ";", true))
|
|
return false ;
|
|
if ( ! ngeIn.ReadDouble( m_dStep, ",", false))
|
|
return false ;
|
|
int nTemp ;
|
|
if ( ! ngeIn.ReadInt( nTemp, ",", false))
|
|
return false ;
|
|
m_nNx = nTemp ;
|
|
if ( ! ngeIn.ReadInt( nTemp, ";", true))
|
|
return false ;
|
|
m_nNy = nTemp ;
|
|
|
|
// dimensione del vettore di dexel
|
|
m_nDim = m_nNx * m_nNy ;
|
|
m_ZValues.resize(m_nDim) ;
|
|
|
|
// ciclo sui dexel
|
|
for ( unsigned int i = 0 ; i < m_nDim ; ++ i) {
|
|
// leggo il numero di estremi nel dexel
|
|
if ( ! ngeIn.ReadInt( nTemp, ",", false))
|
|
return false ;
|
|
// devono essere pari
|
|
if ( ( nTemp % 2) != 0)
|
|
return false ;
|
|
// se dexel nullo
|
|
if ( nTemp == 0) {
|
|
// leggo un valore dummy
|
|
double dDummy ;
|
|
if ( ! ngeIn.ReadDouble( dDummy, ",", true))
|
|
return false ;
|
|
}
|
|
// altrimenti
|
|
else {
|
|
// dimensiono l'array
|
|
m_ZValues[i].resize(nTemp) ;
|
|
// leggo i valori
|
|
for ( unsigned int k = 0 ; k < m_ZValues[i].size() ; ++ k) {
|
|
bool bEndL = ( k == m_ZValues[i].size() - 1) ;
|
|
if ( ! ngeIn.ReadDouble( m_ZValues[i][k], ( bEndL ? ";" : ","), bEndL))
|
|
return false ;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_nStatus = OK ;
|
|
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 * m_dStep, m_nNy * m_dStep, m_dMaxZ)) ;
|
|
b3Loc.ToGlob( m_LocalFrame) ;
|
|
return true ;
|
|
}
|
|
// calcolo preciso
|
|
// ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
|
|
double dY = 0 ;
|
|
for ( size_t j = 0 ; j <= m_nNy ; ++ j) {
|
|
size_t jc = ( ( j != m_nNy) ? j : m_nNy -1) ;
|
|
double dX = 0 ;
|
|
// punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
|
|
for ( size_t i = 0 ; i <= m_nNx ; ++ i) {
|
|
size_t ic = ( ( i != m_nNx) ? i : m_nNx -1) ;
|
|
size_t nPos = ic + jc * m_nNx ;
|
|
if ( m_ZValues[nPos].size() > 0) {
|
|
Point3d ptP = m_LocalFrame.Orig() + dX * m_LocalFrame.VersX() + dY * m_LocalFrame.VersY() ;
|
|
b3Loc.Add( ptP + m_ZValues[nPos][0] * m_LocalFrame.VersZ()) ;
|
|
b3Loc.Add( ptP + m_ZValues[nPos][m_ZValues[nPos].size()-1] * m_LocalFrame.VersZ()) ;
|
|
}
|
|
// passo al punto successivo
|
|
dX += m_dStep ;
|
|
}
|
|
// passo alla riga successiva
|
|
dY += m_dStep ;
|
|
}
|
|
|
|
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_LocalFrame ;
|
|
frUse.ToGlob( frRef) ;
|
|
// se richiesto approssimato
|
|
if ( ( nFlag & BBF_EXACT) == 0) {
|
|
b3Ref.Add( ORIG) ;
|
|
b3Ref.Add( Point3d( m_nNx * m_dStep, m_nNy * m_dStep, m_dMaxZ)) ;
|
|
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 ( size_t j = 0 ; j <= m_nNy ; ++ j) {
|
|
size_t jc = ( ( j != m_nNy) ? j : m_nNy -1) ;
|
|
double dX = 0 ;
|
|
// punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
|
|
for ( size_t i = 0 ; i <= m_nNx ; ++ i) {
|
|
size_t ic = ( ( i != m_nNx) ? i : m_nNx -1) ;
|
|
size_t nPos = ic + jc * m_nNx ;
|
|
if ( m_ZValues[nPos].size() > 0) {
|
|
Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ;
|
|
b3Ref.Add( ptP + m_ZValues[nPos][0] * frUse.VersZ()) ;
|
|
b3Ref.Add( ptP + m_ZValues[nPos][m_ZValues[nPos].size()-1] * frUse.VersZ()) ;
|
|
}
|
|
// passo al punto successivo
|
|
dX += m_dStep ;
|
|
}
|
|
// passo alla riga successiva
|
|
dY += m_dStep ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Translate( const Vector3d& vtMove)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
// traslo il riferimento
|
|
m_LocalFrame.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 ;
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
// ruoto il riferimento
|
|
return m_LocalFrame.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
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 ;
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ToGlob( const Frame3d& frRef)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
// trasformo il riferimento
|
|
return m_LocalFrame.ToGlob( frRef) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::ToLoc( const Frame3d& frRef)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
// trasformo il riferimento
|
|
return m_LocalFrame.ToLoc( frRef) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
VolZmap::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
// trasformo il riferimento
|
|
return m_LocalFrame.LocToLoc( frOri, frDest) ;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|