Egalware/EgtExecutor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'ExtDimension_angular'

Browse Source
This commit is contained in:
Daniele Bariletti
2024-02-05 15:55:46 +01:00
parent f28da6d9e3 41c50a776e
commit 407ca752ab
2 changed files with 79 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EXE_GdbCreate.cpp
+75 -178
View File
@@ -480,7 +480,7 @@ MyCreateRadialDimension( int nParentId, int nCrvId, const Point3d& ptDim,
Point3d ptCenL = pArc->GetCenter() ;
ptCenL.LocToLoc( frArc, frLoc) ;
Vector3d vtNL = pArc->GetNormVersor() ;
vtNL.LocToLoc( frArc, frLoc) ;
vtNL.LocToLoc( frArc, frLoc) ;
// porto ptDimL sulla circonferenza cui appartiene l'arco
Vector3d vtDir = ptDimL - ptCenL ;
if ( ! vtDir.Normalize())
@@ -543,7 +543,7 @@ MyCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
Point3d ptCenL = pArc->GetCenter() ;
ptCenL.LocToLoc( frArc, frLoc) ;
Vector3d vtNL = pArc->GetNormVersor() ;
vtNL.LocToLoc( frArc, frLoc) ;
vtNL.LocToLoc( frArc, frLoc) ;
// porto ptDimL sulla circonferenza
Vector3d vtDir = ptDimL - ptCenL ;
if ( ! vtDir.Normalize())
@@ -583,7 +583,7 @@ ExeCreateDiametralDimension( int nParentId, int nCrvId, const Point3d& ptDim,
//-------------------------------------------------------------------------------
static int
MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2,
const Point3d& ptDim, const string& sText, int nRefType)
{
IGeomDB* pGeomDB = GetCurrGeomDB() ;
@@ -594,7 +594,7 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP
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 ptVL = GetPointLocal( pGeomDB, ptV, nRefType, frLoc) ;
Point3d ptP1L = GetPointLocal( pGeomDB, ptP1, nRefType, frLoc) ;
Point3d ptP2L = GetPointLocal( pGeomDB, ptP2, nRefType, frLoc) ;
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
@@ -603,7 +603,7 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( IsNull( pDim) ||
! MySetDimensionStyle( pDim ) ||
! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimL, vtNL, sText))
! pDim->SetAngular( ptP1L, ptVL, ptP2L, ptDimL, vtNL, sText))
return GDB_ID_NULL ;
// inserisco la quota nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -611,16 +611,16 @@ MyCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP
//-------------------------------------------------------------------------------
int
ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptP0, const Point3d& ptP2,
ExeCreateAngularDimension( int nParentId, const Point3d& ptP1, const Point3d& ptV, const Point3d& ptP2,
const Point3d& ptDim, const string& sText, int nRefType)
{
// eseguo
int nId = MyCreateAngularDimension( nParentId, ptP1, ptP0, ptP2, ptDim, sText, nRefType) ;
int nId = MyCreateAngularDimension( nParentId, ptP1, ptV, ptP2, ptDim, sText, nRefType) ;
ExeSetModified() ;
// se richiesto, salvo il comando Lua equivalente
if ( IsCmdLog()) {
string sLua = "EgtAngularDimension(" + IdToString( nParentId) + ",{" +
ToString( ptP0) + "},{" +
ToString( ptV) + "},{" +
ToString( ptP1) + "},{" +
ToString( ptP2) + "},{" +
ToString( ptDim) + "},'" +
@@ -645,27 +645,24 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
Frame3d frLoc ;
if ( ! pGeomDB->GetGroupGlobFrame( nParentId, frLoc))
return GDB_ID_NULL ;
//recupero le linee
// 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())
if ( IsNull( pL1 ) || ! pL1->IsValid() || IsNull( pL2) || ! pL2->IsValid())
return GDB_ID_NULL ;
//porto tutto nel frLoc
// 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) ;
// recupero il punto lo porto nel riferimento locale
Point3d ptDimL = GetPointLocal( pGeomDB, ptDim, nRefType, frLoc) ;
Vector3d vtNL = GetVectorLocal( pGeomDB, Z_AX, nRefType, frLoc) ;
//recupero i punti e le direzioni
// recupero i punti e le direzioni
Point3d ptP1L, ptP2L, ptP3L, ptP4L ;
Vector3d vtL1, vtL2 ;
pL1->GetStartPoint( ptP1L) ;
@@ -674,15 +671,12 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
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 ;
Point3d ptCenL ;
IntersCurveCurve pInters( *pL1, *pL2) ;
IntCrvCrvInfo Info ;
int nNumeroInters = pInters.GetIntersCount() ;
// se non ho intersezioni estendo
if ( nNumeroInters == 0) {
@@ -691,54 +685,54 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
pL2->ExtendStartByLen( dLen) ;
pL1->ExtendEndByLen( dLen) ;
pL2->ExtendEndByLen( dLen) ;
//faccio intersezione
// 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 {
IntCrvCrvInfo Info ;
pIntersExt.GetIntCrvCrvInfo( 0, Info) ;
// controllo che non siano coincidenti
if ( Info.bOverlap)
return false ;
else
ptP0L = Info.IciA->ptI ;
ptCenL = 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
// se ptDimL è più vicino a ptCenL rispetto agli estremi esterni delle linee, allora tengo gli estremi interni
double dP1Cen = ( ptP1L - ptCenL).Len() ;
double dP2Cen = ( ptP2L - ptCenL).Len() ;
double dDimCen = ( ptDimL - ptCenL).Len() ;
if ( ( dDimCen < dP1Cen || dDimCen < dP2Cen))
// se uno dei due punti è più vicino a ptCenL 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 ) ;
ptP1L = ( dP1Cen < dP2Cen ? 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 ) ;
double dP3Cen = ( ptP3L - ptCenL).Len() ;
double dP4Cen = ( ptP4L - ptCenL).Len() ;
if ( dDimCen < dP3Cen || dDimCen < dP4Cen)
ptP3L = ( ( ptDimL - ptP3L).Len() < ( ptDimL - ptP4L).Len() ? ptP3L : ptP4L) ;
else
ptP3L = ( dP3P0 < dP4P0 ? ptP4L : ptP3L) ;
ptP3L = ( dP3Cen < dP4Cen ? ptP4L : ptP3L) ;
}
// se ho già intesezioni devo capire in quale quadrante si trova ptDim
else {
// recupero l'intersezione
IntCrvCrvInfo Info ;
pInters.GetIntCrvCrvInfo( 0, Info) ;
// controllo che non siano coincidenti
if ( Info.bOverlap)
return false ;
// se non coincidono restituisco l'intersezione
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)) {
ptCenL = Info.IciA->ptI ;
// se le due linee hanno un estremo in comune, estendo le linee da quel lato
if ( ( AreSamePointApprox( ptCenL, ptP1L) || AreSamePointApprox( ptCenL, ptP2L)) &&
( AreSamePointApprox( ptCenL, ptP3L) || AreSamePointApprox( ptCenL, ptP4L))) {
if ( AreSamePointApprox( ptCenL, ptP1L)) {
pL1->ExtendStartByLen(Dist( ptP1L, ptP2L) / 2) ;
pL1->GetStartPoint( ptP1L) ;
}
@@ -746,8 +740,8 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
pL1->ExtendEndByLen(Dist( ptP1L, ptP2L) / 2) ;
pL1->GetEndPoint( ptP2L) ;
}
if ( AreSamePointApprox( ptP0L, ptP3L) ) {
pL2->ExtendStartByLen(Dist( ptP3L, ptP4L) / 2);
if ( AreSamePointApprox( ptCenL, ptP3L)) {
pL2->ExtendStartByLen( Dist( ptP3L, ptP4L) / 2);
pL2->GetStartPoint( ptP3L) ;
}
else {
@@ -755,36 +749,42 @@ MyCreateAngularDimensionFromLines( int nParentId, INTVECTOR vLineIds, const Poin
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) )
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
if ( abs(( ptDim1 - ptP1L).Len() + ( ptCenL - ptDim1).Len() - ( ptCenL - ptP1L).Len()) < EPS_SMALL ||
abs(( ptDim1 - ptP1L).Len() + ( ptCenL - ptP1L ).Len() - ( ptDim1 - ptCenL).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
;
if ( abs(( ptDim2 - ptP3L).Len() + ( ptCenL - ptDim2).Len() - ( ptCenL - ptP3L).Len()) < EPS_SMALL ||
abs(( ptDim2 - ptP3L).Len() + ( ptCenL - ptP3L).Len() - ( ptDim2 - ptCenL).Len()) < EPS_SMALL)
// ptDim è dal lato di ptP1L
;
else
// ptDim è dal lato di ptP2L
ptP3L = ptP4L ;
}
// recupero la normale al piano dell'angolo da quotare
Frame3d frArc;
frArc.Set(ptCenL, ptP1L, ptP3L);
Vector3d vtNL = frArc.VersZ() ;
if ( vtNL * Z_AX < - EPS_SMALL) {
frArc.Set(ptCenL, ptP3L, ptP1L);
vtNL = frArc.VersZ() ;
}
// creo la quota
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( IsNull( pDim ) ||
! MySetDimensionStyle( pDim ) ||
! pDim->SetAngular( ptP1L, ptP0L, ptP3L, ptDimL, vtNL, sText))
! pDim->SetAngular( ptP1L, ptCenL, ptP3L, ptDimL, vtNL, sText))
return GDB_ID_NULL ;
// inserisco la quota nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -825,50 +825,36 @@ MyCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDim
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)
ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nCrvId)) ;
if ( pArc == nullptr)
return GDB_ID_NULL ;
Frame3d frArc;
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 ) ;
// recupero i punti e la normale e li porto nel frame locale
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) ;
Vector3d vtNL = pArc->GetNormVersor() ;
vtNL.LocToLoc( frArc, frLoc) ;
Point3d ptCenL, ptP1L, ptP2L ;
pArc->GetStartPoint( ptP1L) ;
ptP1L.LocToLoc( frArc, frLoc) ;
pArc->GetEndPoint( ptP2L) ;
ptP2L.LocToLoc( frArc, frLoc) ;
pArc->GetCenterPoint( ptCenL) ;
ptCenL.LocToLoc( frArc, frLoc) ;
// 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;
pArc->GetMidPoint( ptMid) ;
Vector3d vtDir = ( ptMid - ptCenL) ;
if ( ! vtDir.Normalize())
return GDB_ID_NULL ;
ptDimL = ptCenL + Dist( ptDimL, ptCenL) * vtDir ;
// creo la quota
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( IsNull( pDim ) ||
! MySetDimensionStyle( pDim) ||
! pDim->SetAngular( ptP1L, ptP0L, ptP2L, ptDimNew, vtNL, sText))
! pDim->SetAngular( ptP1L, ptCenL, ptP2L, ptDimL, vtNL, sText))
return GDB_ID_NULL ;
// inserisco la quota nel DB
return pGeomDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pDim)) ;
@@ -894,93 +880,4 @@ ExeCreateAngularDimensionFromArc( int nParentId, int nCrvId, const Point3d& ptDi
}
// 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 ;
}
}
LUA_GdbCreate.cpp
+4 -35
View File
@@ -400,13 +400,13 @@ LuaCreateDiametralDimension( lua_State* L )
static int
LuaCreateAngularDimension(lua_State* L)
{
// 6 o 7 parametri : ParentId, ptP1, ptP0, ptP2, ptDim, Text [, nRefType]
// 6 o 7 parametri : ParentId, ptP1, ptV, ptP2, ptDim, Text [, nRefType]
int nParentId ;
LuaCheckParam( L, 1, nParentId)
Point3d ptP1 ;
LuaCheckParam( L, 2, ptP1) ;
Point3d ptP0 ;
LuaCheckParam( L, 3, ptP0) ;
Point3d ptV ;
LuaCheckParam( L, 3, ptV) ;
Point3d ptP2 ;
LuaCheckParam( L, 4, ptP2) ;
Point3d ptDim ;
@@ -417,7 +417,7 @@ LuaCreateAngularDimension(lua_State* L)
LuaGetParam( L, 7, nRefType) ;
LuaClearStack( L) ;
// creo la quota angolare
int nId = ExeCreateAngularDimension( nParentId, ptP1, ptP0, ptP2, ptDim, sText, nRefType) ;
int nId = ExeCreateAngularDimension( nParentId, ptP1, ptV, ptP2, ptDim, sText, nRefType) ;
// restituisco il risultato
if ( nId != GDB_ID_NULL)
LuaSetParam( L, nId) ;
@@ -478,36 +478,6 @@ LuaCreateAngularDimensionFromArc( lua_State* L)
return 1 ;
}
//-------------------------------------------------------------------------------
static int
LuaCreateAngularDimensionFromCircle( lua_State* L)
{
// 6 o 7 parametri : nParentId, nCrvId, ptP1, ptP2, ptDim, Text [, nRefType]
int nParentId ;
LuaCheckParam( L, 1, nParentId)
int nCrvId ;
LuaCheckParam( L, 2, nCrvId) ;
Point3d ptP1 ;
LuaCheckParam( L, 3, ptP1) ;
Point3d ptP2 ;
LuaCheckParam( L, 4, ptP2) ;
Point3d ptDim ;
LuaCheckParam( L, 5, ptDim) ;
string sText ;
LuaCheckParam( L, 6, sText) ;
int nRefType = RTY_DEFAULT ;
LuaGetParam( L, 7, nRefType) ;
LuaClearStack( L) ;
// creo la quota allineata
int nId = ExeCreateAngularDimensionFromCircle( nParentId, nCrvId, ptP1, ptP2, ptDim, sText, nRefType) ;
// restituisco il risultato
if ( nId != GDB_ID_NULL)
LuaSetParam( L, nId) ;
else
LuaSetParam( L) ;
return 1 ;
}
//-------------------------------------------------------------------------------
bool
LuaInstallGdbCreate( LuaMgr& luaMgr)
@@ -530,6 +500,5 @@ LuaInstallGdbCreate( LuaMgr& luaMgr)
bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimension", LuaCreateAngularDimension);
bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromLines", LuaCreateAngularDimensionFromLines) ;
bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromArc", LuaCreateAngularDimensionFromArc) ;
bOk = bOk && luaMgr.RegisterFunction( "EgtAngularDimensionFromCircle", LuaCreateAngularDimensionFromCircle) ;
return bOk ;
}