Dario Sassi
766 lines
24 KiB
C++
766 lines
24 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2019-2019
|
|
//----------------------------------------------------------------------------
|
|
// File : ExtDimension.cpp Data : 27.12.19 Versione : 2.2a1
|
|
// Contenuto : Implementazione della classe Dimension (quota).
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 27.12.19 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "ExtDimension.h"
|
|
#include "GeoObjFactory.h"
|
|
#include "NgeWriter.h"
|
|
#include "NgeReader.h"
|
|
#include "FontManager.h"
|
|
#include "FontAux.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EGkExtText.h"
|
|
#include "/EgtDev/Include/EGkUiUnits.h"
|
|
#include <new>
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
static const string IS_MEASURE = "<>" ;
|
|
static const string STD_FONT = "ModernPropS.Nfe" ;
|
|
static const int FONT_WEIGHT = 400 ;
|
|
static const bool FONT_ITALIC = false ;
|
|
static const double FONT_RATIO = 0.75 ;
|
|
static const double FONT_ADDADVANCE = 0 ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
GEOOBJ_REGISTER( EXT_DIMENSION, NGE_E_DIM, ExtDimension) ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
ExtDimension::ExtDimension( void)
|
|
: m_dExtLineLen( 5), m_dArrowLen( 5), m_dTextDist( 2), m_bLenIsMM( true), m_nLenDec( -2), m_sFont( STD_FONT), m_dTextHeight( 10)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ExtDimension::~ExtDimension( void)
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::SetLinear( const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptPos,
|
|
const Vector3d& vtN, const Vector3d& vtDir, const string& sText)
|
|
{
|
|
// dichiaro quota non ancora determinata
|
|
m_nType = DT_NONE ;
|
|
// verifico la definizione del versore normale
|
|
m_vtN = vtN ;
|
|
if ( ! m_vtN.Normalize())
|
|
return false ;
|
|
// porto i punti nel piano definito da P1 e N
|
|
m_ptP1 = ptP1 ;
|
|
m_ptP2 = ptP2 - ( ptP2 - m_ptP1) * m_vtN * m_vtN ;
|
|
m_ptPos = ptPos - ( ptPos - m_ptP1) * m_vtN * m_vtN ;
|
|
// verifico che i punti di misura non siano coincidenti
|
|
if ( AreSamePointApprox( m_ptP1, m_ptP2))
|
|
return false ;
|
|
// direzione di riferimento (nel piano perpendicolare a vtN)
|
|
m_vtDir = vtDir ;
|
|
if ( m_vtDir.IsSmall())
|
|
m_vtDir = m_ptP2 - m_ptP1 ;
|
|
else {
|
|
m_vtDir -= m_vtDir * m_vtN * m_vtN ;
|
|
if ( m_vtDir * ( m_ptP2 - m_ptP1) < 0)
|
|
m_vtDir.Invert() ;
|
|
}
|
|
if ( ! m_vtDir.Normalize())
|
|
return false ;
|
|
// punti estremi della linea di misura ed esterni delle linee di estremità
|
|
Vector3d vtLine = m_vtDir ;
|
|
vtLine.Rotate( m_vtN, 0, 1) ;
|
|
if ( vtLine * ( m_ptPos - m_ptP1) < 0)
|
|
vtLine.Invert() ;
|
|
m_ptP5 = m_ptP1 + vtLine * ( m_ptPos - m_ptP1) * vtLine ;
|
|
m_ptP6 = m_ptP2 + vtLine * ( m_ptPos - m_ptP2) * vtLine ;
|
|
m_ptP3 = m_ptP5 + vtLine * m_dExtLineLen ;
|
|
m_ptP4 = m_ptP6 + vtLine * m_dExtLineLen ;
|
|
// assegnazione del testo
|
|
m_sText = sText ;
|
|
// assegno il tipo
|
|
m_nType = DT_LINEAR ;
|
|
// imposto da calcolare
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ExtDimension*
|
|
ExtDimension::Clone( void) const
|
|
{
|
|
// alloco oggetto
|
|
ExtDimension* pDim = new( nothrow) ExtDimension ;
|
|
if ( pDim != nullptr) {
|
|
if ( ! pDim->CopyFrom( *this)) {
|
|
delete pDim ;
|
|
return nullptr ;
|
|
}
|
|
}
|
|
|
|
return pDim ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::CopyFrom( const IGeoObj* pGObjSrc)
|
|
{
|
|
const ExtDimension* pDim = dynamic_cast<const ExtDimension*>( pGObjSrc) ;
|
|
if ( pDim == nullptr)
|
|
return false ;
|
|
return CopyFrom( *pDim) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::CopyFrom( const ExtDimension& clSrc)
|
|
{
|
|
if ( &clSrc == this)
|
|
return true ;
|
|
m_OGrMgr.Reset() ;
|
|
m_nType = clSrc.m_nType ;
|
|
m_vtN = clSrc.m_vtN ;
|
|
m_vtDir = clSrc.m_vtDir ;
|
|
m_ptP1 = clSrc.m_ptP1 ;
|
|
m_ptP2 = clSrc.m_ptP2 ;
|
|
m_ptP3 = clSrc.m_ptP3 ;
|
|
m_ptP4 = clSrc.m_ptP4 ;
|
|
m_ptP5 = clSrc.m_ptP5 ;
|
|
m_ptP6 = clSrc.m_ptP6 ;
|
|
m_ptPos = clSrc.m_ptPos ;
|
|
m_sText = clSrc.m_sText ;
|
|
m_bToCalc = clSrc.m_bToCalc ;
|
|
m_ptOutPos = clSrc.m_ptOutPos ;
|
|
m_sOutText = clSrc.m_sOutText ;
|
|
m_dExtLineLen = clSrc.m_dExtLineLen ;
|
|
m_dArrowLen = clSrc.m_dArrowLen ;
|
|
m_dTextDist = clSrc.m_dTextDist ;
|
|
m_bLenIsMM = clSrc.m_bLenIsMM ;
|
|
m_nLenDec = clSrc.m_nLenDec ;
|
|
m_sFont = clSrc.m_sFont ;
|
|
m_dTextHeight = clSrc.m_dTextHeight ;
|
|
m_nTempProp = clSrc.m_nTempProp ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
GeoObjType
|
|
ExtDimension::GetType( void) const
|
|
{
|
|
return static_cast<GeoObjType>( GEOOBJ_GETTYPE( ExtDimension)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const string&
|
|
ExtDimension::GetTitle( void) const
|
|
{
|
|
static const string sTitle = "Dimension" ;
|
|
return sTitle ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Dump( string& sOut, bool bMM, const char* szNewLine) const
|
|
{
|
|
// parametri
|
|
sOut += "VN(" + ToString( m_vtN, 6) + ") " + szNewLine ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
ExtDimension::GetNgeId( void) const
|
|
{
|
|
return GEOOBJ_GETNGEID( ExtDimension) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Save( NgeWriter& ngeOut) const
|
|
{
|
|
// tipo
|
|
if ( ! ngeOut.WriteInt( m_nType, ";", true))
|
|
return false ;
|
|
// versori normale e direzione
|
|
if ( ! ngeOut.WriteVector( m_vtN, ";"))
|
|
return false ;
|
|
if ( ! ngeOut.WriteVector( m_vtDir, ";", true))
|
|
return false ;
|
|
// punti di quotatura
|
|
if ( ! ngeOut.WritePoint( m_ptP1, ";"))
|
|
return false ;
|
|
if ( ! ngeOut.WritePoint( m_ptP2, ";"))
|
|
return false ;
|
|
if ( ! ngeOut.WritePoint( m_ptP3, ";"))
|
|
return false ;
|
|
if ( ! ngeOut.WritePoint( m_ptP4, ";", true))
|
|
return false ;
|
|
if ( ! ngeOut.WritePoint( m_ptP5, ";"))
|
|
return false ;
|
|
if ( ! ngeOut.WritePoint( m_ptP6, ";"))
|
|
return false ;
|
|
if ( ! ngeOut.WritePoint( m_ptPos, ";", true))
|
|
return false ;
|
|
// testo
|
|
if ( ! ngeOut.WriteString( m_sText, ";", true))
|
|
return false ;
|
|
// attributi
|
|
if ( ! ngeOut.WriteDouble( m_dExtLineLen, ","))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_dArrowLen, ","))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_dTextDist, ","))
|
|
return false ;
|
|
if ( ! ngeOut.WriteBool( m_bLenIsMM, ","))
|
|
return false ;
|
|
if ( ! ngeOut.WriteInt( m_nLenDec, ","))
|
|
return false ;
|
|
if ( ! ngeOut.WriteString( m_sFont, ","))
|
|
return false ;
|
|
if ( ! ngeOut.WriteDouble( m_dTextHeight, ";", true))
|
|
return false ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Load( NgeReader& ngeIn)
|
|
{
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// leggo la prossima linea : tipo
|
|
if ( ! ngeIn.ReadInt( m_nType, ";", true))
|
|
return false ;
|
|
// leggo la prossima linea : versori normale e direzione
|
|
if ( ! ngeIn.ReadVector( m_vtN, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadVector( m_vtDir, ";", true))
|
|
return false ;
|
|
// leggo la prossima linea : punti di quotatura
|
|
if ( ! ngeIn.ReadPoint( m_ptP1, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_ptP2, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_ptP3, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_ptP4, ";", true))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_ptP5, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_ptP6, ";"))
|
|
return false ;
|
|
if ( ! ngeIn.ReadPoint( m_ptPos, ";", true))
|
|
return false ;
|
|
// leggo la prossima linea : testo
|
|
if ( ! ngeIn.ReadString( m_sText, ";", true))
|
|
return false ;
|
|
// leggo la prossima linea : attributi
|
|
if ( ! ngeIn.ReadDouble( m_dExtLineLen, ","))
|
|
return false ;
|
|
if ( ! ngeIn.ReadDouble( m_dArrowLen, ","))
|
|
return false ;
|
|
if ( ! ngeIn.ReadDouble( m_dTextDist, ","))
|
|
return false ;
|
|
if ( ! ngeIn.ReadBool( m_bLenIsMM, ","))
|
|
return false ;
|
|
if ( ! ngeIn.ReadInt( m_nLenDec, ","))
|
|
return false ;
|
|
if ( ! ngeIn.ReadString( m_sFont, ","))
|
|
return false ;
|
|
if ( ! ngeIn.ReadDouble( m_dTextHeight, ";", true))
|
|
return false ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
|
|
{
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
b3Loc.Set( m_ptP1) ;
|
|
b3Loc.Add( m_ptP2) ;
|
|
b3Loc.Set( m_ptP3) ;
|
|
b3Loc.Add( m_ptP4) ;
|
|
// ingombro del testo
|
|
BBox3d b3Text ;
|
|
if ( GetTextLocalBBox( b3Text))
|
|
b3Loc.Add( b3Text) ;
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
|
|
{
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// porto i punti nel riferimento passato
|
|
Point3d ptFrP1 = m_ptP1 ;
|
|
ptFrP1.ToGlob( frRef) ;
|
|
Point3d ptFrP2 = m_ptP2 ;
|
|
ptFrP2.ToGlob( frRef) ;
|
|
Point3d ptFrP3 = m_ptP3 ;
|
|
ptFrP3.ToGlob( frRef) ;
|
|
Point3d ptFrP4 = m_ptP4 ;
|
|
ptFrP4.ToGlob( frRef) ;
|
|
// assegno il box nel riferimento
|
|
b3Ref.Set( ptFrP1) ;
|
|
b3Ref.Add( ptFrP2) ;
|
|
b3Ref.Add( ptFrP3) ;
|
|
b3Ref.Add( ptFrP4) ;
|
|
// ingombro del testo
|
|
BBox3d b3Text ;
|
|
if ( GetTextBBox( frRef, b3Text))
|
|
b3Ref.Add( b3Text) ;
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Translate( const Vector3d& vtMove)
|
|
{
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
m_ptP1.Translate( vtMove) ;
|
|
m_ptP2.Translate( vtMove) ;
|
|
m_ptP3.Translate( vtMove) ;
|
|
m_ptP4.Translate( vtMove) ;
|
|
m_ptP5.Translate( vtMove) ;
|
|
m_ptP6.Translate( vtMove) ;
|
|
m_ptPos.Translate( vtMove) ;
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
|
|
{
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
return ( m_vtN.Rotate( vtAx, dCosAng, dSinAng) &&
|
|
m_vtDir.Rotate( vtAx, dCosAng, dSinAng) &&
|
|
m_ptP1.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
|
|
m_ptP2.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
|
|
m_ptP3.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
|
|
m_ptP4.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
|
|
m_ptP5.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
|
|
m_ptP6.Rotate( ptAx, vtAx, dCosAng, dSinAng) &&
|
|
m_ptPos.Rotate( ptAx, vtAx, dCosAng, dSinAng)) ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
|
|
{
|
|
// verifico non sia nulla
|
|
if ( abs( dCoeffX) < EPS_ZERO && abs( dCoeffY) < EPS_ZERO && abs( dCoeffZ) < EPS_ZERO)
|
|
return false ;
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// sistemo i vettori
|
|
Vector3d vtTmp = m_vtN ^ m_vtDir ;
|
|
if ( ! vtTmp.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) || ! vtTmp.Normalize())
|
|
return false ;
|
|
if ( ! m_vtDir.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ) || ! m_vtDir.Normalize())
|
|
return false ;
|
|
m_vtN = m_vtDir ^ vtTmp ;
|
|
if ( ! m_vtN.Normalize())
|
|
return false ;
|
|
// scalo i punti di base
|
|
if ( ! m_ptP1.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
|
|
return false ;
|
|
if ( ! m_ptP2.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
|
|
return false ;
|
|
if ( ! m_ptPos.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
|
|
return false ;
|
|
// ricalcolo completamente la quota
|
|
return SetLinear( m_ptP1, m_ptP2, m_ptPos, m_vtN, m_vtDir, m_sText) ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
|
|
{
|
|
// verifico validità del piano di specchiatura
|
|
if ( vtNorm.IsSmall())
|
|
return false ;
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// eseguo il mirror dei versori
|
|
if ( ! m_vtN.Mirror( vtNorm))
|
|
return false ;
|
|
if ( ! m_vtDir.Mirror( vtNorm))
|
|
return false ;
|
|
// eseguo il mirror dei punti
|
|
if ( ! m_ptP1.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
if ( ! m_ptP2.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
if ( ! m_ptP3.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
if ( ! m_ptP4.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
if ( ! m_ptP5.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
if ( ! m_ptP6.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
if ( ! m_ptPos.Mirror( ptOn, vtNorm))
|
|
return false ;
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::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
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// sistemo i vettori
|
|
Vector3d vtTmp = m_vtN ^ m_vtDir ;
|
|
if ( ! vtTmp.Shear( vtNorm, vtDir, dCoeff) || ! vtTmp.Normalize())
|
|
return false ;
|
|
if ( ! m_vtDir.Shear( vtNorm, vtDir, dCoeff) || ! m_vtDir.Normalize())
|
|
return false ;
|
|
m_vtN = m_vtDir ^ vtTmp ;
|
|
if ( ! m_vtN.Normalize())
|
|
return false ;
|
|
// eseguo scorrimento dei punti di base
|
|
if ( ! m_ptP1.Shear( ptOn, vtNorm, vtDir, dCoeff))
|
|
return false ;
|
|
if ( ! m_ptP2.Shear( ptOn, vtNorm, vtDir, dCoeff))
|
|
return false ;
|
|
if ( ! m_ptPos.Shear( ptOn, vtNorm, vtDir, dCoeff))
|
|
return false ;
|
|
// ricalcolo completamente la quota
|
|
return SetLinear( m_ptP1, m_ptP2, m_ptPos, m_vtN, m_vtDir, m_sText) ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::ToGlob( const Frame3d& frRef)
|
|
{
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// trasformo punto e versori
|
|
return ( m_vtN.ToGlob( frRef) &&
|
|
m_vtDir.ToGlob( frRef) &&
|
|
m_ptP1.ToGlob( frRef) &&
|
|
m_ptP2.ToGlob( frRef) &&
|
|
m_ptP3.ToGlob( frRef) &&
|
|
m_ptP4.ToGlob( frRef) &&
|
|
m_ptP5.ToGlob( frRef) &&
|
|
m_ptP6.ToGlob( frRef) &&
|
|
m_ptPos.ToGlob( frRef)) ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::ToLoc( const Frame3d& frRef)
|
|
{
|
|
// verifico validità del frame
|
|
if ( frRef.GetType() == Frame3d::ERR)
|
|
return false ;
|
|
// imposto ricalcolo
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// se lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// trasformo punto e versori
|
|
return ( m_vtN.ToLoc( frRef) &&
|
|
m_vtDir.ToLoc( frRef) &&
|
|
m_ptP1.ToLoc( frRef) &&
|
|
m_ptP2.ToLoc( frRef) &&
|
|
m_ptP3.ToLoc( frRef) &&
|
|
m_ptP4.ToLoc( frRef) &&
|
|
m_ptP5.ToLoc( frRef) &&
|
|
m_ptP6.ToLoc( frRef) &&
|
|
m_ptPos.ToLoc( frRef)) ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::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
|
|
m_bToCalc = true ;
|
|
m_OGrMgr.Reset() ;
|
|
// trasformo punto e versori
|
|
return ( m_vtN.ToGlob( frOri) && m_vtN.ToLoc( frDest) &&
|
|
m_vtDir.ToGlob( frOri) && m_vtDir.ToLoc( frDest) &&
|
|
m_ptP1.ToGlob( frOri) && m_ptP1.ToLoc( frDest) &&
|
|
m_ptP2.ToGlob( frOri) && m_ptP2.ToLoc( frDest) &&
|
|
m_ptP3.ToGlob( frOri) && m_ptP3.ToLoc( frDest) &&
|
|
m_ptP4.ToGlob( frOri) && m_ptP4.ToLoc( frDest) &&
|
|
m_ptP5.ToGlob( frOri) && m_ptP5.ToLoc( frDest) &&
|
|
m_ptP6.ToGlob( frOri) && m_ptP6.ToLoc( frDest) &&
|
|
m_ptPos.ToGlob( frOri) && m_ptPos.ToLoc( frDest)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::Update( void) const
|
|
{
|
|
// se ricalcolo non richiesto, esco
|
|
if ( ! m_bToCalc)
|
|
return true ;
|
|
// se quota lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// testo
|
|
m_sOutText = m_sText ;
|
|
if ( m_sOutText.find( IS_MEASURE) != string::npos) {
|
|
double dVal = ( m_ptP2 - m_ptP1) * m_vtDir * ( m_bLenIsMM ? 1 : 1. / ONEINCH) ;
|
|
string sVal = ToString( dVal, m_nLenDec) ;
|
|
ReplaceString( m_sOutText, IS_MEASURE, sVal) ;
|
|
}
|
|
// punto di inserimento del testo
|
|
m_ptOutPos = ( m_ptP5 + m_ptP6) / 2 ;
|
|
// dichiaro ricalcolo eseguito
|
|
m_bToCalc = false ;
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const
|
|
{
|
|
// eventuale ricalcolo
|
|
if ( m_bToCalc)
|
|
Update() ;
|
|
// se quota lineare
|
|
if ( m_nType == DT_LINEAR) {
|
|
// prima linea di riferimento
|
|
lstPL.emplace_back() ;
|
|
lstPL.back().AddUPoint( 0, m_ptP1) ;
|
|
lstPL.back().AddUPoint( 1, m_ptP3) ;
|
|
// seconda linea di riferimento
|
|
lstPL.emplace_back() ;
|
|
lstPL.back().AddUPoint( 0, m_ptP2) ;
|
|
lstPL.back().AddUPoint( 1, m_ptP4) ;
|
|
// se non c'è testo, linea di misura intera
|
|
if ( IsEmptyOrSpaces( m_sOutText)) {
|
|
lstPL.emplace_back() ;
|
|
lstPL.back().AddUPoint( 0, m_ptP5) ;
|
|
lstPL.back().AddUPoint( 1, m_ptP6) ;
|
|
}
|
|
// altrimenti, linea di misura divisa in due parti
|
|
else {
|
|
// semi distanza di interruzione
|
|
double dHalfDist = m_dTextHeight / 2 + m_dTextDist ;
|
|
// recupero il box di ingombro del testo
|
|
BBox3d b3Text ;
|
|
if ( GetTextLocalBBox( b3Text)) {
|
|
double dHalfL = ( b3Text.GetMax().x - b3Text.GetMin().x) / 2 ;
|
|
double dHalfH = ( b3Text.GetMax().y - b3Text.GetMin().y) / 2 ;
|
|
dHalfDist = sqrt( dHalfL * dHalfL + dHalfH * dHalfH) ;
|
|
if ( abs( m_vtDir.x) > EPS_ZERO)
|
|
dHalfDist = min( dHalfDist, dHalfL / abs( m_vtDir.x)) ;
|
|
if ( abs( m_vtDir.y) > EPS_ZERO)
|
|
dHalfDist = min( dHalfDist, dHalfH / abs( m_vtDir.y)) ;
|
|
dHalfDist += m_dTextDist ;
|
|
}
|
|
// prima parte
|
|
lstPL.emplace_back() ;
|
|
lstPL.back().AddUPoint( 0, m_ptP5) ;
|
|
lstPL.back().AddUPoint( 1, m_ptOutPos - m_vtDir * dHalfDist) ;
|
|
// seconda parte
|
|
lstPL.emplace_back() ;
|
|
lstPL.back().AddUPoint( 0, m_ptOutPos + m_vtDir * dHalfDist) ;
|
|
lstPL.back().AddUPoint( 1, m_ptP6) ;
|
|
}
|
|
// frecce
|
|
lstPL.emplace_back() ;
|
|
GetArrowHead( m_ptP5, -m_vtDir, lstPL.back()) ;
|
|
lstPL.emplace_back() ;
|
|
GetArrowHead( m_ptP6, m_vtDir, lstPL.back()) ;
|
|
// testo
|
|
POLYLINELIST lstTxt ;
|
|
if ( ApproxTextWithLines( dLinTol, dAngTolDeg, lstTxt))
|
|
lstPL.splice( lstPL.end(), lstTxt) ;
|
|
}
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::GetArrowHead( const Point3d& ptTip, const Vector3d& vtDir, PolyLine& PL) const
|
|
{
|
|
Vector3d vtPerp = vtDir ^ m_vtN ;
|
|
if ( ! vtPerp.Normalize())
|
|
return false ;
|
|
const double A_WIDTH_COEFF = 0.1666 ;
|
|
PL.AddUPoint( 0, ptTip) ;
|
|
PL.AddUPoint( 1, ptTip - ( vtDir + vtPerp * A_WIDTH_COEFF) * m_dArrowLen) ;
|
|
PL.AddUPoint( 2, ptTip - ( vtDir - vtPerp * A_WIDTH_COEFF) * m_dArrowLen) ;
|
|
PL.AddUPoint( 4, ptTip) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::ApproxTextWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const
|
|
{
|
|
// eventuale ricalcolo
|
|
if ( m_bToCalc)
|
|
Update() ;
|
|
|
|
// imposto il font corrente e i suoi dati
|
|
FontManager& fntMgr = FontManager::GetFontManager() ;
|
|
if ( ! fntMgr.SetCurrFont( m_sFont, FONT_WEIGHT, FONT_ITALIC, m_dTextHeight, FONT_RATIO, FONT_ADDADVANCE))
|
|
return false ;
|
|
|
|
// richiedo l'outline
|
|
if ( ! fntMgr.ApproxWithLines( m_sOutText, ETXT_IPMC, dLinTol, dAngTolDeg, lstPL))
|
|
return false ;
|
|
|
|
// calcolo la trasformazione
|
|
Frame3d frRef ;
|
|
if ( ! frRef.Set( m_ptOutPos, m_vtN))
|
|
return false ;
|
|
|
|
// eseguo la trasformazione
|
|
for ( auto& PL : lstPL)
|
|
PL.ToGlob( frRef) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::GetTextMyBBox( const Point3d& ptPos, BBox3d& b3Loc) const
|
|
{
|
|
// imposto box vuoto
|
|
b3Loc.Reset() ;
|
|
|
|
// se testo vuoto, box vuoto
|
|
if ( IsEmptyOrSpaces( m_sOutText))
|
|
return true ;
|
|
|
|
// imposto il font corrente e i suoi dati
|
|
FontManager& fntMgr = FontManager::GetFontManager() ;
|
|
if ( ! fntMgr.SetCurrFont( m_sFont, FONT_WEIGHT, FONT_ITALIC, m_dTextHeight, FONT_RATIO, FONT_ADDADVANCE))
|
|
return false ;
|
|
|
|
// richiedo il box
|
|
if ( ! fntMgr.GetBBox( m_sOutText, ETXT_IPMC, b3Loc))
|
|
return false ;
|
|
|
|
// calcolo ed eseguo la trasformazione
|
|
Frame3d frRef ;
|
|
if ( ! frRef.Set( ptPos, m_vtN))
|
|
return false ;
|
|
b3Loc.ToGlob( frRef) ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::GetTextLocalBBox( BBox3d& b3Loc) const
|
|
{
|
|
// eventuale ricalcolo
|
|
if ( m_bToCalc)
|
|
Update() ;
|
|
|
|
// calcolo il box
|
|
return GetTextMyBBox( m_ptOutPos, b3Loc) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExtDimension::GetTextBBox( const Frame3d& frRef, BBox3d& b3Ref) const
|
|
{
|
|
// eventuale ricalcolo
|
|
if ( m_bToCalc)
|
|
Update() ;
|
|
|
|
// calcolo il box
|
|
if ( ! GetTextMyBBox( m_ptOutPos, b3Ref))
|
|
return false ;
|
|
|
|
// porto il box nel riferimento passato
|
|
b3Ref.ToGlob( frRef) ;
|
|
|
|
return true ;
|
|
}
|