Dario Sassi
41a38fef3b
- aggiunta entità testo (con font Nfe e di sistema) - in tutte le rotate ora l'angolo è in gradi - aggiunta trasformazione Shear (scorrimento) - aggiunta trsformazione LocToLoc - Set/GetInfo specializzate per i diversi tipi di informazioni - Copy e Relocate con possibilità di indicare l'entità di riferimento rispetto a cui inserire - aggiunte trasformazioni a PolyLine.
578 lines
15 KiB
C++
578 lines
15 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2014
|
|
//----------------------------------------------------------------------------
|
|
// File : CurveLine.cpp Data : 06.05.14 Versione : 1.5e3
|
|
// Contenuto : Implementazione della classe Segmento di Linea.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 16.04.13 DS Creazione modulo.
|
|
// 06.05.14 DS Aggiunta Set per Pini, vtDir, Len e per Pini, AngDir, Len.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "CurveLine.h"
|
|
#include "GeoObjFactory.h"
|
|
#include "NgeWriter.h"
|
|
#include "NgeReader.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include <new>
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
GEOOBJ_REGISTER( CRV_LINE, NGE_C_LIN, CurveLine) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
CurveLine::CurveLine( void)
|
|
: m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd()
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
CurveLine::~CurveLine( void)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Set( const Point3d& ptStart, const Point3d& ptEnd)
|
|
{
|
|
// assegno i dati
|
|
m_PtStart = ptStart ;
|
|
m_PtEnd = ptEnd ;
|
|
m_nStatus = TO_VERIFY ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
|
|
{
|
|
// assegno i dati
|
|
m_PtStart = ptStart ;
|
|
Vector3d vtDelta = vtDir ;
|
|
if ( ! vtDelta.Normalize())
|
|
return false ;
|
|
vtDelta *= dLen ;
|
|
m_PtEnd = ptStart + vtDelta ;
|
|
m_nStatus = TO_VERIFY ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen)
|
|
{
|
|
// assegno i dati
|
|
m_PtStart = ptStart ;
|
|
Vector3d vtDelta ;
|
|
vtDelta.FromPolar( dLen, dDirAngDeg) ;
|
|
m_PtEnd = ptStart + vtDelta ;
|
|
m_nStatus = TO_VERIFY ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
CurveLine*
|
|
CurveLine::Clone( void) const
|
|
{
|
|
// alloco oggetto
|
|
CurveLine* pCrv = new(nothrow) CurveLine ;
|
|
if ( pCrv != nullptr) {
|
|
if ( ! pCrv->Copy( *this)) {
|
|
delete pCrv ;
|
|
return nullptr ;
|
|
}
|
|
}
|
|
|
|
return pCrv ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Copy( const IGeoObj* pGObjSrc)
|
|
{
|
|
const CurveLine* pCL = dynamic_cast<const CurveLine*>( pGObjSrc) ;
|
|
if ( pCL == nullptr)
|
|
return false ;
|
|
return Copy( *pCL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Copy( const CurveLine& clSrc)
|
|
{
|
|
if ( &clSrc == this)
|
|
return true ;
|
|
return Set( clSrc.m_PtStart, clSrc.m_PtEnd) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeoObjType
|
|
CurveLine::GetType( void) const
|
|
{
|
|
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( CurveLine)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string&
|
|
CurveLine::GetTitle( void) const
|
|
{
|
|
static const string sTitle = "Line" ;
|
|
return sTitle ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Dump( string& sOut, const char* szNewLine) const
|
|
{
|
|
// parametri : punti iniziale e finale
|
|
sOut += "P1(" + ToString( m_PtStart, 3) + ")" + szNewLine ;
|
|
sOut += "P2(" + ToString( m_PtEnd, 3) + ")" + szNewLine ;
|
|
// altri dati : angolo vert, angolo orizz, lunghezza
|
|
double dLen, dAngVertDeg, dAngOrizzDeg ;
|
|
( m_PtEnd - m_PtStart).ToSpherical( &dLen, &dAngVertDeg, &dAngOrizzDeg) ;
|
|
sOut += "Av=" + ToString( dAngVertDeg, 3) + " Ao=" + ToString( dAngOrizzDeg, 3) +
|
|
" L=" + ToString( dLen, 3) + szNewLine ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
CurveLine::GetNgeId( void) const
|
|
{
|
|
return GEOOBJ_GETNGEID( CurveLine) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Save( NgeWriter& ngeOut) const
|
|
{
|
|
// parametri : punti iniziale e finale
|
|
ngeOut.WritePoint( m_PtStart, ";") ;
|
|
ngeOut.WritePoint( m_PtEnd, ";", true) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Load( NgeReader& ngeIn)
|
|
{
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
// leggo la prossima linea
|
|
if ( ! ngeIn.ReadPoint( m_PtStart, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_PtEnd, ";", true))
|
|
return false ;
|
|
// eseguo validazione
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetLocalBBox( BBox3d& b3Loc) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// assegno il box in locale
|
|
b3Loc.Set( m_PtStart, m_PtEnd) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetBBox( const Frame3d& frRef, BBox3d& b3Ref) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
// porto gli estremi nel riferimento passato
|
|
Point3d ptFrStart = m_PtStart ;
|
|
ptFrStart.ToGlob( frRef) ;
|
|
Point3d ptFrEnd = m_PtEnd ;
|
|
ptFrEnd.ToGlob( frRef) ;
|
|
// assegno il box nel riferimento
|
|
b3Ref.Set( ptFrStart, ptFrEnd) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Validate( void)
|
|
{
|
|
if ( m_nStatus == TO_VERIFY)
|
|
m_nStatus = ( ( SqDist( m_PtStart, m_PtEnd) > EPS_SMALL * EPS_SMALL) ? OK : ERR) ;
|
|
|
|
return ( m_nStatus == OK) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetStartPoint( Point3d& ptStart) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// assegno il punto
|
|
ptStart = m_PtStart ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetEndPoint( Point3d& ptEnd) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// assegno il punto
|
|
ptEnd = m_PtEnd ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetMidPoint( Point3d& ptMid) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// assegno il punto
|
|
ptMid = Media( m_PtStart, m_PtEnd, 0.5) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetStartDir( Vector3d& vtDir) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// calcolo la direzione
|
|
vtDir = m_PtEnd - m_PtStart ;
|
|
return vtDir.Normalize() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetPointD1D2( double dU, Side nS, Point3d& ptPos, Vector3d* pvtDer1, Vector3d* pvtDer2) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// il parametro U deve essere compreso tra 0 e 1
|
|
if ( dU < 0)
|
|
dU = 0 ;
|
|
else if ( dU > 1)
|
|
dU = 1 ;
|
|
|
|
// calcolo del punto
|
|
ptPos = Media( m_PtStart, m_PtEnd, dU) ;
|
|
|
|
// calcolo della derivata prima
|
|
if ( pvtDer1 != nullptr)
|
|
*pvtDer1 = m_PtEnd - m_PtStart ;
|
|
|
|
// derivata seconda nulla
|
|
if ( pvtDer2 != nullptr && pvtDer1 != nullptr)
|
|
pvtDer2->Set( 0, 0, 0) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::GetLength( double& dLen) const
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// la lunghezza è la distanza tra gli estremi
|
|
dLen = Dist( m_PtStart, m_PtEnd) ;
|
|
|
|
return ( dLen > EPS_SMALL) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::ApproxWithLines( double dLinTol, double dAngTolDeg, PolyLine& PL) const
|
|
{
|
|
// pulisco la polilinea
|
|
PL.Clear() ;
|
|
|
|
// la curva deve essere validata
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// inserisco gli estremi
|
|
PL.AddUPoint( 0, m_PtStart) ;
|
|
PL.AddUPoint( 1, m_PtEnd) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Invert( void)
|
|
{
|
|
// verifico lo stato
|
|
if ( m_nStatus != OK)
|
|
return false ;
|
|
|
|
// inverto i punti estremi
|
|
swap( m_PtStart, m_PtEnd) ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::TrimStartAtParam( double dUTrim)
|
|
{
|
|
// riporto i parametri nel loro range
|
|
dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
|
|
|
|
// recupero lunghezza
|
|
double dLen ;
|
|
if ( ! GetLength( dLen))
|
|
return false ;
|
|
|
|
// utilizzo il trim sulle lunghezze
|
|
return TrimStartAtLen( dUTrim * dLen) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::TrimEndAtParam( double dUTrim)
|
|
{
|
|
// riporto i parametri nel loro range
|
|
dUTrim = ( ( dUTrim < 0) ? 0 : (( dUTrim > 1) ? 1 : dUTrim)) ;
|
|
|
|
// recupero lunghezza
|
|
double dLen ;
|
|
if ( ! GetLength( dLen))
|
|
return false ;
|
|
|
|
// utilizzo il trim sulle lunghezze
|
|
return TrimEndAtLen( dUTrim * dLen) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::TrimStartAtLen( double dLenTrim)
|
|
{
|
|
// lunghezze negative vengono considerate nulle
|
|
dLenTrim = __max( dLenTrim, 0) ;
|
|
|
|
// verifico che sia abbastanza lunga
|
|
double dLen ;
|
|
if ( ! GetLength( dLen))
|
|
return false ;
|
|
if ( ( dLen - dLenTrim) < EPS_SMALL)
|
|
return false ;
|
|
|
|
// eseguo il trim
|
|
if ( dLenTrim > EPS_ZERO)
|
|
m_PtStart = Media( m_PtStart, m_PtEnd, ( dLenTrim / dLen)) ;
|
|
|
|
// con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::TrimEndAtLen( double dLenTrim)
|
|
{
|
|
// lunghezze negative vengono considerate nulle
|
|
dLenTrim = __max( dLenTrim, 0) ;
|
|
|
|
// verifico che sia abbastanza lunga
|
|
double dLen ;
|
|
if ( ! GetLength( dLen))
|
|
return false ;
|
|
if ( dLenTrim < EPS_SMALL)
|
|
return false ;
|
|
|
|
// eseguo il trim
|
|
if ( ( dLen - dLenTrim) > EPS_ZERO)
|
|
m_PtEnd = Media( m_PtStart, m_PtEnd, ( dLenTrim / dLen)) ;
|
|
|
|
// con i controlli sopra fatti rimane validata, ma la grafica va ricalcolata
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Translate( const Vector3d& vtMove)
|
|
{
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// traslo i punti estremi
|
|
m_PtStart.Translate( vtMove) ;
|
|
m_PtEnd.Translate( vtMove) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
|
|
{
|
|
// verifico validità dell'asse di rotazione
|
|
if ( vtAx.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// ruoto i punti estremi
|
|
m_PtStart.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
|
|
m_PtEnd.Rotate( ptAx, vtAx, dCosAng, dSinAng) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
|
|
{
|
|
// verifico non sia nulla
|
|
if ( fabs( dCoeffX) < EPS_ZERO && fabs( dCoeffY) < EPS_ZERO && fabs( dCoeffZ) < EPS_ZERO)
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// scalo i punti estremi
|
|
m_PtStart.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
|
|
m_PtEnd.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) ;
|
|
m_nStatus = TO_VERIFY ;
|
|
|
|
return Validate() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
|
|
{
|
|
// verifico validità del piano di specchiatura
|
|
if ( vtNorm.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// specchio i punti estremi
|
|
m_PtStart.Mirror( ptOn, vtNorm) ;
|
|
m_PtEnd.Mirror( ptOn, vtNorm) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff)
|
|
{
|
|
// verifico validità dei parametri
|
|
if ( vtNorm.IsSmall() || vtDir.IsSmall())
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// eseguo scorrimento dei punti estremi
|
|
m_PtStart.Shear( ptOn, vtNorm, vtDir, dCoeff) ;
|
|
m_PtEnd.Shear( ptOn, vtNorm, vtDir, dCoeff) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::ToGlob( const Frame3d& frRef)
|
|
{
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// trasformo i punti estremi
|
|
return ( m_PtStart.ToGlob( frRef) && m_PtEnd.ToGlob( frRef)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::ToLoc( const Frame3d& frRef)
|
|
{
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
|
|
// imposto ricalcolo della grafica
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// trasformo i punti estremi
|
|
return ( m_PtStart.ToLoc( frRef) && m_PtEnd.ToLoc( frRef)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
CurveLine::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
|
|
{
|
|
// 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
|
|
m_OGrMgr.Reset() ;
|
|
|
|
// trasformo i punti estremi
|
|
return ( m_PtStart.ToGlob( frOri) && m_PtStart.ToLoc( frDest) &&
|
|
m_PtEnd.ToGlob( frOri) && m_PtEnd.ToLoc( frDest)) ;
|
|
}
|