DarioS
987 lines
42 KiB
C++
987 lines
42 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : EXE_GdbCreate.cpp Data : 04.05.15 Versione : 1.6e1
|
|
// Contenuto : Funzioni di creazione oggetti del DB geometrico per EXE.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 30.09.14 DS Creazione modulo.
|
|
// 07.01.15 DS Agg. scrittura comandi Lua.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "EXE.h"
|
|
#include "EXE_Macro.h"
|
|
#include "AuxTools.h"
|
|
#include "GeoTools.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EGkGeoVector3d.h"
|
|
#include "/EgtDev/Include/EGkExtText.h"
|
|
#include "/EgtDev/Include/EGkExtDimension.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EgtStringConverter.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
#include "/EgtDev/Include/EGkIntersCurves.h"
|
|
#include "/EgtDev/Include/EGkCurveLine.h"
|
|
#include "/EgtDev/Include/EGkCurveArc.h"
|
|
#include "/EgtDev/Include/EGkDistPointCurve.h"
|
|
#include "/EgtDev/Include/EGkCurveComposite.h"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateGroup( int nParentId, const Frame3d& frFrame, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc ) ;
|
|
// porto in locale l'origine e i versori
|
|
Point3d ptOrigL = GetPointLocal( pGeomDB, frFrame.Orig(), nRefType, frLoc) ;
|
|
Vector3d vtXL = GetVectorLocal( pGeomDB, frFrame.VersX(), nRefType, frLoc) ;
|
|
Vector3d vtYL = GetVectorLocal( pGeomDB, frFrame.VersY(), nRefType, frLoc) ;
|
|
Vector3d vtZL = GetVectorLocal( pGeomDB, frFrame.VersZ(), nRefType, frLoc) ;
|
|
// costruisco il riferimento
|
|
Frame3d frFrameL ;
|
|
bOk = bOk && frFrameL.Set( ptOrigL, vtXL, vtYL, vtZL) ;
|
|
// creo il gruppo
|
|
int nId = ( bOk ? pGeomDB->AddGroup( GDB_ID_NULL, nParentId, frFrameL) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua ;
|
|
if ( AreSameFrame( frFrame, GLOB_FRM)) {
|
|
if ( nRefType == RTY_LOC)
|
|
sLua = "EgtGroup(" + IdToString( nParentId) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
else
|
|
sLua = "EgtGroup(" + IdToString( nParentId) + "," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
}
|
|
else
|
|
sLua = "EgtGroup(" + IdToString( nParentId) + ",{{" +
|
|
ToString( frFrame.Orig()) + "},{" +
|
|
ToString( frFrame.VersX()) + "},{" +
|
|
ToString( frFrame.VersY()) + "},{" +
|
|
ToString( frFrame.VersZ()) + "}}," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del nuovo gruppo
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateGeoPoint( int nParentId, const Point3d& ptP, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
|
|
// porto in locale il punto
|
|
Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
|
|
// creo il punto
|
|
PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
|
|
bOk = bOk && !IsNull( pGeoPnt) ;
|
|
// setto il punto
|
|
bOk = bOk && pGeoPnt->Set( ptPL) ;
|
|
// inserisco il punto nel DB
|
|
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoPnt)) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtPoint(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP) + "}," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo della nuova entit�
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateGeoVector( int nParentId, const Vector3d& vtV, const Point3d& ptB, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
|
|
// porto in locale il vettore e il punto
|
|
Vector3d vtVL = GetVectorLocal( pGeomDB, vtV, nRefType, frLoc) ;
|
|
Point3d ptBL = GetPointLocal( pGeomDB, ptB, nRefType, frLoc) ;
|
|
// creo il vettore
|
|
PtrOwner<IGeoVector3d> pGeoVct( CreateGeoVector3d()) ;
|
|
bOk = bOk && !IsNull( pGeoVct) ;
|
|
// setto il vettore (con il punto base)
|
|
bOk = bOk && pGeoVct->Set( vtVL, ptBL) ;
|
|
// inserisco il vettore nel DB
|
|
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoVct)) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua ;
|
|
if ( ptB.IsSmall())
|
|
sLua = "EgtVector(" + IdToString( nParentId) + ",{" +
|
|
ToString( vtV) + "}," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
else
|
|
sLua = "EgtVector(" + IdToString( nParentId) + ",{" +
|
|
ToString( vtV) + "},{" +
|
|
ToString( ptB) + "}," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo della nuova entit�
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateGeoFrame( int nParentId, const Frame3d& frFrame, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc ) ;
|
|
// porto in locale l'origine e i versori
|
|
Point3d ptOrigL = GetPointLocal( pGeomDB, frFrame.Orig(), nRefType, frLoc) ;
|
|
Vector3d vtXL = GetVectorLocal( pGeomDB, frFrame.VersX(), nRefType, frLoc) ;
|
|
Vector3d vtYL = GetVectorLocal( pGeomDB, frFrame.VersY(), nRefType, frLoc) ;
|
|
Vector3d vtZL = GetVectorLocal( pGeomDB, frFrame.VersZ(), nRefType, frLoc) ;
|
|
// creo e setto il riferimento
|
|
PtrOwner<IGeoFrame3d> pGeoFrm( CreateGeoFrame3d()) ;
|
|
bOk = bOk && !IsNull( pGeoFrm) ;
|
|
bOk = bOk && pGeoFrm->Set( ptOrigL, vtXL, vtYL, vtZL) ;
|
|
// inserisco il riferimento nel DB
|
|
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pGeoFrm)) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtFrame(" + IdToString( nParentId) + ",{{" +
|
|
ToString( frFrame.Orig()) + "},{" +
|
|
ToString( frFrame.VersX()) + "},{" +
|
|
ToString( frFrame.VersY()) + "},{" +
|
|
ToString( frFrame.VersZ()) + "}}," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del nuovo gruppo
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateText( int nParentId, const Point3d& ptP,
|
|
const string& sText, double dH, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
|
|
// porto in locale l'origine e i versori
|
|
Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
Vector3d vtDL = GetVectorLocal( pGeomDB, X_AX, nRefType, frLoc) ;
|
|
// creo il testo e lo riempio
|
|
PtrOwner<IExtText> pTXT( CreateExtText()) ;
|
|
bOk = bOk && !IsNull( pTXT) ;
|
|
bOk = bOk && pTXT->Set( ptPL, vtNL, vtDL, sText, "", false, dH) ;
|
|
// inserisco il testo nel DB
|
|
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtText(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
ToString( dH) + "," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateTextEx( int nParentId, const Point3d& ptP, double dAngRotDeg,
|
|
const string& sText, const string& sFont, bool bItalic, double dH, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
|
|
// porto in locale l'origine e i versori
|
|
Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
Vector3d vtDL = GetVectorLocal( pGeomDB, FromPolar( 1, dAngRotDeg), nRefType, frLoc) ;
|
|
// creo il testo e lo riempio
|
|
PtrOwner<IExtText> pTXT( CreateExtText()) ;
|
|
bOk = bOk && !IsNull( pTXT) ;
|
|
bOk = bOk && pTXT->Set( ptPL, vtNL, vtDL, sText, sFont, bItalic, dH) ;
|
|
// inserisco il testo nel DB
|
|
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtTextEx(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP) + "}," +
|
|
ToString( dAngRotDeg) + ",'" +
|
|
StringToLuaString( sText) + "','" +
|
|
StringToLuaString( sFont) + "'," +
|
|
( bItalic ? "'I'" : "'S'") + "," +
|
|
ToString( dH) + "," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateTextAdv( int nParentId, const Point3d& ptP, double dAngRotDeg,
|
|
const string& sText, const string& sFont,
|
|
int nW, bool bItalic, double dH, double dRat, double dAddAdv, int nInsPos, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
bool bOk = true ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nParentId, frLoc) ;
|
|
// porto in locale l'origine e i versori
|
|
Point3d ptPL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
Vector3d vtDL = GetVectorLocal( pGeomDB, FromPolar( 1, dAngRotDeg), nRefType, frLoc) ;
|
|
// creo il testo e lo imposto
|
|
PtrOwner<IExtText> pTXT( CreateExtText()) ;
|
|
bOk = bOk && !IsNull( pTXT) ;
|
|
bOk = bOk && pTXT->Set( ptPL, vtNL, vtDL, sText, sFont, nW, bItalic, dH, dRat, dAddAdv, nInsPos) ;
|
|
// inserisco il testo nel DB
|
|
int nId = ( bOk ? pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pTXT)) : GDB_ID_NULL) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtTextAdv(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP) + "}," +
|
|
ToString( dAngRotDeg) + ",'" +
|
|
StringToLuaString( sText) + "','" +
|
|
StringToLuaString( sFont) + "'," +
|
|
ToString( nW) + "," +
|
|
( bItalic ? "'I'" : "'S'") + "," +
|
|
ToString( dH) + "," +
|
|
ToString( dRat) + "," +
|
|
ToString( dAddAdv) + "," +
|
|
ETxtInsPosToString( nInsPos) + "," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeSetCurrDimensionStyle( double dExtLineLen, double dArrowLen, double dTextDist,
|
|
int nLenIsMM, int nDecDigit, const string& sFont, double dTextHeight)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX( pGseCtx, false)
|
|
// aggiorno lo stile di quotatura corrente
|
|
pGseCtx->m_dsCurr.Set( dExtLineLen, dArrowLen, dTextDist, nLenIsMM, nDecDigit, sFont, dTextHeight) ;
|
|
return true ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeResetCurrDimensionStyle( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX( pGseCtx, false)
|
|
// aggiorno lo stile di quotatura corrente
|
|
pGseCtx->m_dsCurr.Reset() ;
|
|
return true ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static bool
|
|
MySetDimensionStyle( IExtDimension* pDim)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX( pGseCtx, false)
|
|
// verifico validit� quotatura
|
|
if ( pDim == nullptr)
|
|
return false ;
|
|
// recupero lo stile di quotatura
|
|
const DimensionStyle& DimSt = pGseCtx->m_dsCurr ;
|
|
// recupero l'unit� di misura lineare per la quotatura
|
|
bool bLenIsMM = ( DimSt.nLenIsMM == 2 ? ExeUiUnitsAreMM() : ( DimSt.nLenIsMM != 0 )) ;
|
|
// imposto lo stile
|
|
return pDim->SetStyle( DimSt.dExtLineLen, DimSt.dArrowLen, DimSt.dTextDist,
|
|
bLenIsMM, DimSt.nDecDigit, DimSt.sFont, DimSt.dTextHeight) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateLinearDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
|
|
const Point3d& ptDim, const Vector3d& vtDir, const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc ))
|
|
return GDB_ID_NULL ;
|
|
// porto in locale i punti e assegno i versori
|
|
Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
|
|
Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
Vector3d vtDL = GetVectorLocal( pGeomDB, vtDir, nRefType, frLoc) ;
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim ) ||
|
|
! MySetDimensionStyle( pDim ) ||
|
|
! pDim->SetLinear( ptP1L, ptP2L, ptDimL, vtNL, vtDL, sText ))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateHorizontalDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
|
|
const Point3d& ptDim, const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateLinearDimension( nParentId, ptP1, ptP2, ptDim, X_AX, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtHorizontalDimension(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP1) + "},{" +
|
|
ToString( ptP2) + "},{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateVerticalDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
|
|
const Point3d& ptDim, const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateLinearDimension( nParentId, ptP1, ptP2, ptDim, Y_AX, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtVerticalDimension(" + IdToString( nParentId ) + ",{" +
|
|
ToString( ptP1) + "},{" +
|
|
ToString( ptP2) + "},{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateAlignedDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP2,
|
|
const Point3d& ptDim, const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateLinearDimension( nParentId, ptP1, ptP2, ptDim, V_NULL, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtAlignedDimension(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP1) + "},{" +
|
|
ToString( ptP2) + "},{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
|
|
return GDB_ID_NULL ;
|
|
// recupero l'arco di circonferenza e il suo frame
|
|
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
|
|
if ( pArc == nullptr)
|
|
return GDB_ID_NULL ;
|
|
Frame3d frArc ;
|
|
if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
|
|
return GDB_ID_NULL ;
|
|
// porto il punto nel riferimento locale
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
// recupero il centro e la normale e li porto nel riferimento locale
|
|
Point3d ptCenL = pArc->GetCenter() ;
|
|
ptCenL.LocToLoc( frArc, frLoc) ;
|
|
Vector3d vtNL = pArc->GetNormVersor() ;
|
|
vtNL.LocToLoc( frArc, frLoc) ;
|
|
// porto ptDimL sulla circonferenza cui appartiene l'arco
|
|
Vector3d vtDir = ptDimL - ptCenL ;
|
|
if ( ! vtDir.Normalize())
|
|
return GDB_ID_NULL ;
|
|
ptDimL = ptCenL + pArc->GetRadius() * vtDir ;
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim) ||
|
|
! MySetDimensionStyle( pDim) ||
|
|
! pDim->SetRadial( ptCenL, ptDimL, vtNL, sText))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateRadialDimension( nParentId, nCrvId, ptDim, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtRadialDimension(" + IdToString( nParentId) + "," +
|
|
IdToString( nCrvId) + ",{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
|
|
return GDB_ID_NULL ;
|
|
// recupero l'arco e il suo frame
|
|
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
|
|
if ( pArc == nullptr)
|
|
return GDB_ID_NULL ;
|
|
Frame3d frArc ;
|
|
if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
|
|
return GDB_ID_NULL ;
|
|
// porto il punto nel riferimento locale
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
// recupero il centro e la normale e li porto nel riferimento locale
|
|
Point3d ptCenL = pArc->GetCenter() ;
|
|
ptCenL.LocToLoc( frArc, frLoc) ;
|
|
Vector3d vtNL = pArc->GetNormVersor() ;
|
|
vtNL.LocToLoc( frArc, frLoc) ;
|
|
// porto ptDimL sulla circonferenza
|
|
Vector3d vtDir = ptDimL - ptCenL ;
|
|
if ( ! vtDir.Normalize())
|
|
return GDB_ID_NULL ;
|
|
ptDimL = ptCenL + pArc->GetRadius() * vtDir ;
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim) ||
|
|
! MySetDimensionStyle( pDim) ||
|
|
! pDim->SetDiametral( ptCenL, ptDimL, vtNL, sText))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateDiametralDimension( nParentId, nCrvId, ptDim, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtDiametralDimension(" + IdToString( nParentId) + "," +
|
|
IdToString( nCrvId) + ",{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
|
|
const Point3d& ptDim, const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
|
|
return GDB_ID_NULL ;
|
|
// porto in locale i punti e assegno i versori
|
|
Point3d ptP0L = GetPointLocal( pGeomDB, ptP0, nRefType, frLoc) ;
|
|
Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
|
|
Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim) ||
|
|
! MySetDimensionStyle( pDim ) ||
|
|
! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimL, vtNL, sText))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
|
|
const Point3d& ptDim, const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateAngularDimension( nParentId, ptP1, ptP0, ptP2, ptDim, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtAngularDimension(" + IdToString( nParentId) + ",{" +
|
|
ToString( ptP0) + "},{" +
|
|
ToString( ptP1) + "},{" +
|
|
ToString( ptP2) + "},{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
|
|
return GDB_ID_NULL ;
|
|
|
|
//recupero le linee
|
|
ICurveLine* pCrv1 = GetCurveLine( pGeomDB->GetGeoObj( vLineIds[0])) ;
|
|
ICurveLine* pCrv2 = GetCurveLine( pGeomDB->GetGeoObj( vLineIds[1])) ;
|
|
if ( pCrv1 == nullptr || pCrv2 == nullptr)
|
|
return GDB_ID_NULL ;
|
|
PtrOwner<ICurveLine> pL1( pCrv1->Clone()) ;
|
|
PtrOwner<ICurveLine> pL2( pCrv2->Clone()) ;
|
|
if ( IsNull( pL1 ) || ! pL1->IsValid() || IsNull( pL2) || ! pL2->IsValid())
|
|
return GDB_ID_NULL ;
|
|
|
|
//porto tutto nel frLoc
|
|
Frame3d frL1, frL2 ;
|
|
if ( ! pGeomDB->GetGlobFrame( vLineIds[0], frL1) || ! pGeomDB->GetGlobFrame( vLineIds[1], frL2))
|
|
return GDB_ID_NULL ;
|
|
pL1->LocToLoc( frL1, frLoc) ;
|
|
pL2->LocToLoc( frL2, frLoc) ;
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
|
|
//recupero i punti e le direzioni
|
|
Point3d ptP1L, ptP2L, ptP3L, ptP4L ;
|
|
Vector3d vtL1, vtL2 ;
|
|
pL1->GetStartPoint( ptP1L) ;
|
|
pL1->GetEndPoint( ptP2L) ;
|
|
pL2->GetStartPoint( ptP3L) ;
|
|
pL2->GetEndPoint( ptP4L) ;
|
|
pL1->GetStartDir( vtL1) ;
|
|
pL2->GetStartDir( vtL2) ;
|
|
|
|
// controllo se le rette sono coincidenti o parallele
|
|
if ( AreSameOrOppositeVectorApprox( vtL1, vtL2))
|
|
return GDB_ID_NULL ;
|
|
|
|
// verifico se le rette si intersecano già
|
|
Point3d ptP0L ;
|
|
IntersCurveCurve pInters( *pL1, *pL2) ;
|
|
IntCrvCrvInfo Info ;
|
|
int nNumeroInters = pInters.GetIntersCount() ;
|
|
// se non ho intersezioni estendo
|
|
if ( nNumeroInters == 0) {
|
|
double dLen = pow( 10, 5) ;
|
|
pL1->ExtendStartByLen( dLen) ;
|
|
pL2->ExtendStartByLen( dLen) ;
|
|
pL1->ExtendEndByLen( dLen) ;
|
|
pL2->ExtendEndByLen( dLen) ;
|
|
|
|
//faccio intersezione
|
|
IntersCurveCurve pIntersExt( *pL1, *pL2) ;
|
|
nNumeroInters = pIntersExt.GetIntersCount() ;
|
|
|
|
// le linee estese non si intersecano, quindi vuol dire che sono quasi parallele e lontanissime
|
|
if ( nNumeroInters == 0 )
|
|
return GDB_ID_NULL ;
|
|
else {
|
|
pIntersExt.GetIntCrvCrvInfo( 0, Info) ;
|
|
// controllo che non siano coincidenti
|
|
if ( Info.bOverlap)
|
|
return false ;
|
|
else
|
|
ptP0L = Info.IciA->ptI ;
|
|
}
|
|
// seleziono i punti necessari
|
|
// se ptDimL è più vicino a ptP0L rispetto agli estremi esterni delle linee, allora tengo gli estremi interni
|
|
double dP1P0 = ( ptP1L - ptP0L ).Len() ;
|
|
double dP2P0 = ( ptP2L - ptP0L ).Len() ;
|
|
double dDimP0 = ( ptDimL - ptP0L ).Len() ;
|
|
if ( ( dDimP0 < dP1P0 || dDimP0 < dP2P0))
|
|
// se uno dei due punti è più vicino a ptP0L rispetto a ptDimL, allora tengo il punto più vicino a ptDimL
|
|
ptP1L = ( ( ptDimL - ptP1L ).Len() < ( ptDimL - ptP2L ).Len() ? ptP1L : ptP2L) ;
|
|
else
|
|
ptP1L = ( dP1P0 < dP2P0 ? ptP2L : ptP1L ) ;
|
|
// rifaccio anche per l'altro lato
|
|
double dP3P0 = ( ptP3L - ptP0L).Len() ;
|
|
double dP4P0 = ( ptP4L - ptP0L).Len() ;
|
|
if ( dDimP0 < dP3P0 || dDimP0 < dP4P0 )
|
|
ptP3L = ( ( ptDimL - ptP3L).Len() < ( ptDimL - ptP4L).Len() ? ptP3L : ptP4L ) ;
|
|
else
|
|
ptP3L = ( dP3P0 < dP4P0 ? ptP4L : ptP3L) ;
|
|
}
|
|
// se ho già intesezioni devo capire in quale quadrante si trova ptDim
|
|
else {
|
|
// recupero l'intersezione
|
|
pInters.GetIntCrvCrvInfo( 0, Info) ;
|
|
// controllo che non siano coincidenti
|
|
if ( Info.bOverlap)
|
|
return false ;
|
|
else
|
|
ptP0L = Info.IciA->ptI ; // se non coincidono restituisco l'intersezione
|
|
|
|
// se le due linee hanno un estremo in comune, estendo le linee quel lato
|
|
if ( ( AreSamePointApprox( ptP0L, ptP1L) || AreSamePointApprox( ptP0L, ptP2L)) &&
|
|
( AreSamePointApprox( ptP0L, ptP3L) || AreSamePointApprox( ptP0L, ptP4L))) {
|
|
if ( AreSamePointApprox( ptP0L, ptP1L)) {
|
|
pL1->ExtendStartByLen(Dist( ptP1L, ptP2L) / 2) ;
|
|
pL1->GetStartPoint( ptP1L) ;
|
|
}
|
|
else {
|
|
pL1->ExtendEndByLen(Dist( ptP1L, ptP2L) / 2) ;
|
|
pL1->GetEndPoint( ptP2L) ;
|
|
}
|
|
if ( AreSamePointApprox( ptP0L, ptP3L) ) {
|
|
pL2->ExtendStartByLen(Dist( ptP3L, ptP4L) / 2);
|
|
pL2->GetStartPoint( ptP3L) ;
|
|
}
|
|
else {
|
|
pL2->ExtendEndByLen(Dist( ptP3L, ptP4L) / 2);
|
|
pL2->GetEndPoint( ptP4L) ;
|
|
}
|
|
}
|
|
|
|
// seleziono i punti necessari
|
|
// proietto pdDim su vtLine1 e su vtLine2
|
|
Point3d ptDim1, ptDim2 ;
|
|
DistPointCurve distPL1( ptDimL, *pL1, true) ;
|
|
DistPointCurve distPL2( ptDimL, *pL2, true) ;
|
|
int nFlag1, nFlag2 ;
|
|
if ( ! distPL1.GetMinDistPoint( 0, ptDim1, nFlag1) || ! distPL2.GetMinDistPoint( 0, ptDim2, nFlag2) )
|
|
return false ;
|
|
if ( abs(( ptDim1 - ptP1L).Len() + ( ptP0L - ptDim1).Len() - ( ptP0L - ptP1L).Len()) < EPS_SMALL ||
|
|
abs(( ptDim1 - ptP1L).Len() + ( ptP0L - ptP1L ).Len() - ( ptDim1 - ptP0L).Len()) < EPS_SMALL)
|
|
// ptDim è dal lato di ptP1L, quindi tengo ptP1L
|
|
;
|
|
else
|
|
// ptDim è dal lato di ptP2L
|
|
ptP1L = ptP2L ;
|
|
if ( abs(( ptDim2 - ptP3L).Len() + ( ptP0L - ptDim2).Len() - ( ptP0L - ptP3L).Len()) < EPS_SMALL ||
|
|
abs(( ptDim2 - ptP3L).Len() + ( ptP0L - ptP3L).Len() - ( ptDim2 - ptP0L).Len()) < EPS_SMALL)
|
|
// ptDim è dal lato di ptP1L, quindi tengo ptP3L
|
|
;
|
|
else
|
|
// ptDim è dal lato di ptP2L
|
|
ptP3L = ptP4L ;
|
|
}
|
|
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim ) ||
|
|
! MySetDimensionStyle( pDim ) ||
|
|
! pDim->SetAngular( ptP1L, ptP0L, ptP3L, ptDimL, vtNL, sText))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateAngularDimensionFromLines( int nParentId, const INTVECTOR vLineIds, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateAngularDimensionFromLines( nParentId, vLineIds, ptDim, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtAngularDimensionFromLines(" + IdToString( nParentId) + "," +
|
|
ToString( vLineIds[0]) + "," +
|
|
ToString( vLineIds[1]) + ",{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
|
|
return GDB_ID_NULL ;
|
|
|
|
// recupero l'arco e il suo frame
|
|
ICurveArc* pCurve = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
|
|
if ( pCurve == nullptr)
|
|
return GDB_ID_NULL ;
|
|
Frame3d frArc;
|
|
if ( ! pGeomDB->GetGlobFrame( nCrvId, frArc))
|
|
return GDB_ID_NULL ;
|
|
|
|
PtrOwner<ICurveArc> pCrv( pCurve->Clone()) ;
|
|
if ( IsNull( pCrv ) || ! pCrv->IsValid())
|
|
return GDB_ID_NULL ;
|
|
|
|
// porto tutto nel frLoc
|
|
pCrv->LocToLoc( frArc, frLoc ) ;
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
|
|
//recupero i punti e i versori
|
|
Point3d ptP0L, ptP1L, ptP2L ;
|
|
pCrv->GetStartPoint( ptP1L) ;
|
|
pCrv->GetEndPoint( ptP2L) ;
|
|
pCrv->GetCenterPoint( ptP0L) ;
|
|
|
|
// porto ptDimL nell'area di influenza dell'arco
|
|
Point3d ptDimNew ;
|
|
double dDist = ( ptDimL - ptP0L).Len() ;
|
|
Point3d ptMid ;
|
|
pCrv->GetMidPoint( ptMid) ;
|
|
Vector3d vtDir = ( ptMid - ptP0L) ;
|
|
vtDir.Normalize() ;
|
|
ptDimNew = ptP0L + dDist * vtDir ;
|
|
// proietto il punto sul piano XY della griglia
|
|
Frame3d frGrid = pGeomDB->GetGridFrame() ;
|
|
if ( ! frGrid.IsValid())
|
|
return GDB_ID_NULL ;
|
|
Point3d ptOrig = frGrid.Orig() ;
|
|
ptDimNew -= ( ptDimNew - ptOrig) * vtNL * vtNL;
|
|
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim ) ||
|
|
! MySetDimensionStyle( pDim) ||
|
|
! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimNew, vtNL, sText))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateAngularDimensionFromArc( nParentId, nCrvId, ptDim, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtAngularDimensionFromArc(" + IdToString( nParentId) + "," +
|
|
IdToString( nCrvId) + ",{" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
MyCreateAngularDimensionFromCircle( int nParentId, int nCrvId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
nParentId = AdjustId( nParentId ) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
|
|
return GDB_ID_NULL ;
|
|
|
|
// recupero il cerchio e il suo frame
|
|
ICurveArc* pCurve = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
|
|
if ( pCurve == nullptr)
|
|
return GDB_ID_NULL ;
|
|
Frame3d frCrv;
|
|
if ( ! pGeomDB->GetGlobFrame( nCrvId, frCrv))
|
|
return GDB_ID_NULL ;
|
|
|
|
PtrOwner<ICurveArc> pCrv( pCurve->Clone()) ;
|
|
if ( IsNull( pCrv ) || ! pCrv->IsValid())
|
|
return GDB_ID_NULL ;
|
|
|
|
// porto tutto nel frLoc
|
|
pCrv->LocToLoc( frCrv, frLoc ) ;
|
|
Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
|
|
Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
|
|
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
|
|
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
|
|
|
|
// recupero il centro
|
|
Point3d ptP0L ;
|
|
pCrv->GetCenterPoint( ptP0L) ;
|
|
|
|
// verifico che i punti P1 e P2 siano sul cerchio, sennò prendo i più vicini
|
|
if ( ! pCrv->IsPointOn(ptP1L)) {
|
|
DistPointCurve distPC( ptP1L, *pCrv) ;
|
|
int nFlag ;
|
|
distPC.GetMinDistPoint(0,ptP1L,nFlag);
|
|
}
|
|
if ( ! pCrv->IsPointOn(ptP2L)) {
|
|
DistPointCurve distPC(ptP2L, *pCrv) ;
|
|
int nFlag ;
|
|
distPC.GetMinDistPoint(0, ptP2L, nFlag);
|
|
}
|
|
|
|
// proietto il punto sul piano XY della griglia
|
|
Frame3d frGrid = pGeomDB->GetGridFrame() ;
|
|
if ( ! frGrid.IsValid())
|
|
return GDB_ID_NULL ;
|
|
Point3d ptOrig = frGrid.Orig() ;
|
|
ptDimL -= ( ptDimL - ptOrig) * vtNL * vtNL;
|
|
|
|
// creo la quota
|
|
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
|
|
if ( IsNull( pDim) ||
|
|
! MySetDimensionStyle( pDim) ||
|
|
! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimL, vtNL, sText))
|
|
return GDB_ID_NULL ;
|
|
// inserisco la quota nel DB
|
|
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeCreateAngularDimensionFromCircle( int nParentId, int nCrvId, const Point3d& ptP1, const Point3d& ptP2, const Point3d& ptDim,
|
|
const string& sText, int nRefType)
|
|
{
|
|
// eseguo
|
|
int nId = MyCreateAngularDimensionFromCircle( nParentId, nCrvId, ptP1, ptP2, ptDim, sText, nRefType) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtAngularDimensionFromCircle(" + IdToString( nParentId) + "," +
|
|
IdToString( nCrvId) + ",{" +
|
|
ToString( ptP1) + "},'" +
|
|
ToString( ptP2) + "},'" +
|
|
ToString( ptDim) + "},'" +
|
|
StringToLuaString( sText) + "'," +
|
|
RefTypeToString( nRefType) + ")" +
|
|
" -- Id=" + ToString( nId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo del oggetto
|
|
return nId ;
|
|
}
|