From eacbbc1c1f1123c4e5245d06cfeb95b4affbc424 Mon Sep 17 00:00:00 2001 From: Dario Sassi Date: Sat, 21 Oct 2017 17:04:10 +0000 Subject: [PATCH] EgtExecutor : - aggiunte funzioni Exe e Lua GetSurfTmPlaneInters. --- EXE_GdbCreateCurve.cpp | 12 ++- EXE_GdbCreateSurf.cpp | 3 +- EXE_GdbModifySurf.cpp | 208 ++++++++++++++++++++++++++++++++++++++++- LUA_GdbModifySurf.cpp | 35 ++++++- 4 files changed, 246 insertions(+), 12 deletions(-) diff --git a/EXE_GdbCreateCurve.cpp b/EXE_GdbCreateCurve.cpp index e4dd569..0ed482c 100644 --- a/EXE_GdbCreateCurve.cpp +++ b/EXE_GdbCreateCurve.cpp @@ -1717,12 +1717,15 @@ MyCreateCurveCompoByChain( int nParentId, const INTVECTOR& vIds, // se non sono state inserite curve, vado oltre if ( pCrvCompo->GetCurveCount() == 0) continue ; - // se curva chiusa entro la tolleranza effettiva di concatenamento ma considerata aperta, la chiudo bene - double dRealToler = chainC.GetTolerance() ; + // se curva di lunghezza inferiore a 2 volte la tolleranza, vado oltre + double dCrvLen ; + if ( ! pCrvCompo->GetLength( dCrvLen) || dCrvLen < 2. * dToler) + continue ; + // se curva chiusa entro 2 volte la tolleranza di concatenamento ma considerata aperta, la chiudo bene Point3d ptStart, ptEnd ; if ( pCrvCompo->GetStartPoint( ptStart) && pCrvCompo->GetEndPoint( ptEnd) && - AreSamePointEpsilon( ptStart, ptEnd, dRealToler) && + AreSamePointEpsilon( ptStart, ptEnd, 2. * dToler) && ! AreSamePointApprox( ptStart, ptEnd)) { // porto il punto finale a coincidere esattamente con l'inizio pCrvCompo->ModifyEnd( ptStart) ; @@ -1756,9 +1759,10 @@ MyCreateCurveCompoByChain( int nParentId, const INTVECTOR& vIds, } } } - // restituisco l'identificativo della prima nuova entità + // aggiorno contatore if ( pnCount != nullptr) *pnCount = nCount ; + // restituisco l'identificativo della prima nuova entità return nFirstId ; } diff --git a/EXE_GdbCreateSurf.cpp b/EXE_GdbCreateSurf.cpp index c8546f2..9da0311 100644 --- a/EXE_GdbCreateSurf.cpp +++ b/EXE_GdbCreateSurf.cpp @@ -986,8 +986,7 @@ ExeCreateSurfTmByTriangles( int nParentId, const INTVECTOR& vIds, bool bErase) // aggiusto per i sistemi di riferimento Tria.LocToLoc( frSou, frLoc) ; // inserisco il triangolo nella nuova superficie - if ( ! StmFts.AddTriangle( Tria)) - return false ; + bOk = bOk && StmFts.AddTriangle( Tria) ; // passo al triangolo successivo nT = pStmS->GetNextTriangle( nT, Tria) ; } diff --git a/EXE_GdbModifySurf.cpp b/EXE_GdbModifySurf.cpp index da2ab10..af7807e 100644 --- a/EXE_GdbModifySurf.cpp +++ b/EXE_GdbModifySurf.cpp @@ -15,15 +15,21 @@ #include "stdafx.h" #include "EXE.h" #include "EXE_Macro.h" +#include "EXE_Const.h" #include "AuxTools.h" #include "GeoTools.h" #include "/EgtDev/Include/EXeExecutor.h" #include "/EgtDev/Include/EXeConst.h" -#include "/EgtDev/Include/EgkCurveComposite.h" -#include "/EgtDev/Include/EgkSurfFlatRegion.h" -#include "/EgtDev/Include/EgkSurfTriMesh.h" -#include "/EgtDev/Include/EgkSurfLocal.h" -#include "/EgtDev/Include/EgkCDSimpleSurfFrMove.h" +#include "/EgtDev/Include/EGkGeoPoint3d.h" +#include "/EgtDev/Include/EGkCurveLine.h" +#include "/EgtDev/Include/EGkCurveComposite.h" +#include "/EgtDev/Include/EGkSurfFlatRegion.h" +#include "/EgtDev/Include/EGkSurfTriMesh.h" +#include "/EgtDev/Include/EGkSurfLocal.h" +#include "/EgtDev/Include/EgkChainCurves.h" +#include "/EgtDev/Include/EGkStmFromTriangleSoup.h" +#include "/EgtDev/Include/EGkCDSimpleSurfFrMove.h" +#include "/EgtDev/Include/EGkIntersPlaneSurfTm.h" #include "/EgtDev/Include/EGkStringUtils3d.h" #include "/EgtDev/Include/EgtPointerOwner.h" @@ -600,6 +606,198 @@ ExeCopySurfTmFacet( int nId, int nFacet, int nDestGrpId) return nFacId ; } +//------------------------------------------------------------------------------- +static int +MyGetSurfTmPlaneInters( int nId, const Point3d& ptOn, const Vector3d& vtN, int nDestGrpId, int nRefType, + int* pnPntCount, int* pnCrvCount, int* pnSrfCount) +{ + IGeomDB* pGeomDB = GetCurrGeomDB() ; + VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL) + // recupero la superficie TriMesh + const ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( nId)) ; + if ( pStm == nullptr) + return GDB_ID_NULL ; + // recupero il suo riferimento globale + Frame3d frSurf ; + if ( ! pGeomDB->GetGlobFrame( nId, frSurf)) + return GDB_ID_NULL ; + // recupero il riferimento del gruppo di destinazione + Frame3d frDest ; + if ( ! pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest)) + return GDB_ID_NULL ; + // porto in locale il punto e la normale del piano + Point3d ptOnL = GetPointLocal( pGeomDB, ptOn, nRefType, frSurf) ; + Vector3d vtNL = GetVectorLocal( pGeomDB, vtN, nRefType, frSurf) ; + // calcolo il piano di intersezione + Plane3d plPlane ; + if ( ! plPlane.Set( ptOnL, vtNL)) + return GDB_ID_NULL ; + // eseguo l'intersezione + PNTVECTOR vPnt ; + BIPNTVECTOR vBpt ; + TRIA3DVECTOR vTria ; + if ( ! IntersPlaneSurfTm( plPlane, *pStm, vPnt, vBpt, vTria)) + return GDB_ID_NULL ; + // Inserisco il risultato nel DB + int nFirstId = GDB_ID_NULL ; + int nPntCount = 0 ; + int nCrvCount = 0 ; + int nSrfCount = 0 ; + // Inserisco i punti nel DB + for ( size_t i = 0 ; i < vPnt.size() ; ++ i) { + // creo il punto + PtrOwner pGeoPnt( CreateGeoPoint3d()) ; + if ( ! IsNull( pGeoPnt)) + return GDB_ID_NULL ; + // setto il punto + pGeoPnt->Set( vPnt[i]) ; + // porto il punto nel riferimento destinazione + pGeoPnt->LocToLoc( frSurf, frDest) ; + // lo inserisco nel DB geometrico + int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pGeoPnt)) ; + if ( nNewId == GDB_ID_NULL) + return GDB_ID_NULL ; + // copio il materiale + if ( ! pGeomDB->CopyMaterial( nId, nNewId)) + return GDB_ID_NULL ; + // aggiorno contatori + if ( nFirstId == GDB_ID_NULL) + nFirstId = nNewId ; + ++ nPntCount ; + } + // Concateno i tratti di curva + double dToler = 20 * EPS_SMALL ; + ChainCurves chainC ; + chainC.Init( false, dToler, int( vBpt.size())) ; + for ( size_t i = 0 ; i < vBpt.size() ; ++ i) { + Vector3d vtDir = vBpt[i].second - vBpt[i].first ; + vtDir.Normalize() ; + if ( ! chainC.AddCurve( int( i) + 1, vBpt[i].first, vtDir, vBpt[i].second, vtDir)) + return GDB_ID_NULL ; + } + // recupero i percorsi concatenati + Point3d ptNear = ( vBpt.empty() ? ORIG : vBpt[0].first) ; + INTVECTOR vId ; + while ( chainC.GetChainFromNear( ptNear, false, vId)) { + // creo una curva composita + PtrOwner pCrvCompo( CreateCurveComposite()) ; + if ( IsNull( pCrvCompo)) + return GDB_ID_NULL ; + // recupero gli estremi dei segmenti, creo le linee e le inserisco nella composita + for ( size_t i = 0 ; i < vId.size() ; ++ i) { + // creo una segmento di retta + int nInd = vId[i] - 1 ; + PtrOwner pLine( CreateCurveLine()) ; + if ( IsNull( pLine) || ! pLine->Set( vBpt[nInd].first, vBpt[nInd].second)) + return GDB_ID_NULL ; + // lo accodo alla composita + if ( ! pCrvCompo->AddCurve( Release( pLine), true, dToler)) + return GDB_ID_NULL ; + // aggiorno il prossimo near + ptNear = vBpt[nInd].second ; + } + // se lunghezza curva inferiore a 5 volte la tolleranza, la salto + double dCrvLen ; + if ( ! pCrvCompo->GetLength( dCrvLen) || dCrvLen < 5. * dToler) + continue ; + // se curva chiusa entro 5 volte la tolleranza ma considerata aperta, la chiudo bene + Point3d ptStart, ptEnd ; + if ( pCrvCompo->GetStartPoint( ptStart) && + pCrvCompo->GetEndPoint( ptEnd) && + AreSamePointEpsilon( ptStart, ptEnd, 5. * dToler) && + ! AreSamePointApprox( ptStart, ptEnd)) { + // porto il punto finale a coincidere esattamente con l'inizio + pCrvCompo->ModifyEnd( ptStart) ; + } + // assegno estrusione come direzione normale al piano + pCrvCompo->SetExtrusion( plPlane.GetVersN()) ; + // unisco segmenti allineati + pCrvCompo->MergeCurves( 0.5 * dToler, ANG_TOL_STD_DEG) ; + // porto la curva nel riferimento destinazione + pCrvCompo->LocToLoc( frSurf, frDest) ; + // la inserisco nel DB geometrico + int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pCrvCompo)) ; + if ( nNewId == GDB_ID_NULL) + return GDB_ID_NULL ; + // copio il materiale + if ( ! pGeomDB->CopyMaterial( nId, nNewId)) + return GDB_ID_NULL ; + // aggiorno contatori + if ( nFirstId == GDB_ID_NULL) + nFirstId = nNewId ; + ++ nCrvCount ; + } + // Costruisco una superficie trimesh dall'insieme di triangoli + StmFromTriangleSoup StmFts ; + if ( ! StmFts.Start()) + return GDB_ID_NULL ; + for ( size_t i = 0 ; i < vTria.size() ; ++ i) + // inserisco il triangolo nella nuova superficie + StmFts.AddTriangle( vTria[i]) ; + // valido la superficie e calcolo le adiacenze + if ( ! StmFts.End()) + return GDB_ID_NULL ; + // se superficie con triangoli + PtrOwner pNewStm( StmFts.GetSurf()) ; + if ( ! IsNull( pNewStm) && pNewStm->GetTriangleCount() > 0) { + // porto la superficie nel riferimento destinazione + pNewStm->LocToLoc( frSurf, frDest) ; + // la inserisco nel DB + int nNewId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, Release( pNewStm)) ; + if ( nNewId == GDB_ID_NULL) + return GDB_ID_NULL ; + // copio il materiale + if ( ! pGeomDB->CopyMaterial( nId, nNewId)) + return GDB_ID_NULL ; + // aggiorno contatori + if ( nFirstId == GDB_ID_NULL) + nFirstId = nNewId ; + ++ nSrfCount ; + } + // aggiorno contatori + if ( pnPntCount != nullptr) + *pnPntCount = nPntCount ; + if ( pnCrvCount != nullptr) + *pnCrvCount = nCrvCount ; + if ( pnSrfCount != nullptr) + *pnSrfCount = nSrfCount ; + // restituisco l'identificativo della prima nuova entità + return nFirstId ; +} + +//------------------------------------------------------------------------------- +int +ExeGetSurfTmPlaneInters( int nId, const Point3d& ptOn, const Vector3d& vtN, int nDestGrpId, int nRefType, + int* pnPntCount, int* pnCrvCount, int* pnSrfCount) +{ + // eseguo + int nPntCount = 0 ; + int nCrvCount = 0 ; + int nSrfCount = 0 ; + int nFirstId = MyGetSurfTmPlaneInters( nId, ptOn, vtN, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ; + // aggiorno contatori + if ( pnPntCount != nullptr) + *pnPntCount = nPntCount ; + if ( pnCrvCount != nullptr) + *pnCrvCount = nCrvCount ; + if ( pnSrfCount != nullptr) + *pnSrfCount = nSrfCount ; + ExeSetModified() ; + // se richiesto, salvo il comando Lua equivalente + if ( IsCmdLog()) { + string sLua = "EgtGetSurfTmPlaneInters(" + ToString( nId) + ",{" + + ToString( ptOn) + "},{" + + ToString( vtN) + "}," + + ToString( nDestGrpId) + "," + + RefTypeToString( nRefType) + ")" + + " -- Id1=" + ToString( nFirstId) + ", PntNbr=" + ToString( nPntCount) + + ", CrvNbr=" + ToString( nCrvCount) + ", SrfNbr=" + ToString( nSrfCount) ; + LOG_INFO( GetCmdLogger(), sLua.c_str()) ; + } + // restituisco l'identificativo della prima nuova entità + return nFirstId ; +} + //------------------------------------------------------------------------------- bool ExeCutSurfTm( int nId, const Point3d& ptOn, const Vector3d& vtN, bool bSaveOnEq, int nRefType) diff --git a/LUA_GdbModifySurf.cpp b/LUA_GdbModifySurf.cpp index 533720a..5c57218 100644 --- a/LUA_GdbModifySurf.cpp +++ b/LUA_GdbModifySurf.cpp @@ -293,6 +293,38 @@ LuaCopySurfTmFacet( lua_State* L) return 1 ; } +//---------------------------------------------------------------------------- +static int +LuaGetSurfTmPlaneInters( lua_State* L) +{ + // 4 o 5 parametri : Id, ptOn, vtN, nDestGrpId [, nRefType] + int nId ; + LuaCheckParam( L, 1, nId) + Point3d ptOn ; + LuaCheckParam( L, 2, ptOn) + Vector3d vtN ; + LuaCheckParam( L, 3, vtN) + int nDestGrpId ; + LuaGetParam( L, 4, nDestGrpId) ; + int nRefType = RTY_DEFAULT ; + LuaGetParam( L, 5, nRefType) ; + LuaClearStack( L) ; + // eseguo l'intersezione + int nPntCount = 0 ; + int nCrvCount = 0 ; + int nSrfCount = 0 ; + int nNewId = ExeGetSurfTmPlaneInters( nId, ptOn, vtN, nDestGrpId, nRefType, &nPntCount, &nCrvCount, &nSrfCount) ; + // restituisco il risultato + if ( nNewId != GDB_ID_NULL) + LuaSetParam( L, nNewId) ; + else + LuaSetParam( L) ; + LuaSetParam( L, nPntCount) ; + LuaSetParam( L, nCrvCount) ; + LuaSetParam( L, nSrfCount) ; + return 4 ; +} + //---------------------------------------------------------------------------- static int LuaCutSurfTm( lua_State* L) @@ -309,7 +341,7 @@ LuaCutSurfTm( lua_State* L) int nRefType = RTY_DEFAULT ; LuaGetParam( L, 5, nRefType) ; LuaClearStack( L) ; - // recupero i contorni della faccetta della superficie + // taglio la superficie bool bOk = ExeCutSurfTm( nId, ptOn, vtN, bSaveOnEq, nRefType) ; // restituisco il risultato LuaSetParam( L, bOk) ; @@ -334,6 +366,7 @@ LuaInstallGdbModifySurf( LuaMgr& luaMgr) bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfTmSilhouette", LuaGetSurfTmSilhouette) ; bOk = bOk && luaMgr.RegisterFunction( "EgtExtractSurfTmFacetLoops", LuaExtractSurfTmFacetLoops) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCopySurfTmFacet", LuaCopySurfTmFacet) ; + bOk = bOk && luaMgr.RegisterFunction( "EgtGetSurfTmPlaneInters", LuaGetSurfTmPlaneInters) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCutSurfTm", LuaCutSurfTm) ; return bOk ; }