Daniele Bariletti
926 lines
31 KiB
C++
926 lines
31 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2020-2022
|
|
//----------------------------------------------------------------------------
|
|
// File : EXE_GeoSnap.cpp Data : 11.04.22 Versione : 2.4d1
|
|
// Contenuto : Funzioni di interrogazione di curve del DBG per EXE.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 23.03.20 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "EXE.h"
|
|
#include "EXE_Const.h"
|
|
#include "EXE_Macro.h"
|
|
#include "AuxTools.h"
|
|
#include "GeoTools.h"
|
|
#include "/EgtDev/Include/EgtNumUtils.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EXeConst.h"
|
|
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EGkCurve.h"
|
|
#include "/EgtDev/Include/EGkCurveArc.h"
|
|
#include "/EgtDev/Include/EGkCurveBezier.h"
|
|
#include "/EgtDev/Include/EGkCurveComposite.h"
|
|
#include "/EgtDev/Include/EGkCurveAux.h"
|
|
#include "/EgtDev/Include/EGkDistPointCurve.h"
|
|
#include "/EgtDev/Include/EGkIntersCurves.h"
|
|
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveDomain( int nId, double* pdStart, double* pdEnd)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico i parametri
|
|
if ( pdStart == nullptr || pdEnd == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// recupero il dominio
|
|
return ( pCurve != nullptr && pCurve->GetDomain( *pdStart, *pdEnd)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveLength( int nId, double* pdLen)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdLen == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// recupero la lunghezza
|
|
return ( pCurve != nullptr && pCurve->GetLength( *pdLen)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveLengthAtParam( int nId, double dPar, double* pdLen)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdLen == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// recupero la lunghezza
|
|
return ( pCurve != nullptr && pCurve->GetLengthAtParam( dPar, *pdLen)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveParamAtLength( int nId, double dLen, double* pdPar)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdPar == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// recupero il parametro in corrispondenza dLen
|
|
return ( pCurve != nullptr && pCurve->GetParamAtLength( dLen, *pdPar)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveParamAtPoint( int nId, const Point3d& ptP, double dTol, int nRefType, double* pdPar)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdPar == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
bool bOk = ( pCurve != nullptr) ;
|
|
// recupero il riferimento locale
|
|
Frame3d frLoc ;
|
|
bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
|
|
// porto il punto in locale
|
|
Point3d ptL = GetPointLocal( pGeomDB, ptP, nRefType, frLoc) ;
|
|
// recupero il parametro in corrispondenza ptL
|
|
return ( bOk && pCurve->GetParamAtPoint( ptL, *pdPar, dTol)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveLengthAtPoint( int nId, const Point3d& ptOn, double dExtend, double* pdLen)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdLen == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
const ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCurve == nullptr)
|
|
return false ;
|
|
// determino la posizione parametrica del punto sulla curva (con tolleranza)
|
|
int nFlag ;
|
|
double dU ;
|
|
if ( ! DistPointCurve( ptOn, *pCurve).GetParamAtMinDistPoint( 0, dU, nFlag) || nFlag != MDPCI_NORMAL)
|
|
return false ;
|
|
// se non richiesta estensione o punto interno alla curva, recupero la lunghezza alla posizione parametrica
|
|
if ( dExtend < EPS_SMALL ||
|
|
( ! pCurve->IsStartParam( dU) && ! pCurve->IsEndParam( dU)))
|
|
return ( pCurve->GetLengthAtParam( dU, *pdLen) ? true : false) ;
|
|
// allungo la curva dalla parte del punto
|
|
PtrOwner<ICurve> pCopy( pCurve->Clone()) ;
|
|
if ( IsNull( pCopy))
|
|
return false ;
|
|
double dDeltaIni ;
|
|
if ( pCopy->IsStartParam( dU)) {
|
|
pCopy->ExtendStartByLen( dExtend) ;
|
|
dDeltaIni = dExtend ;
|
|
}
|
|
else {
|
|
pCopy->ExtendEndByLen( dExtend) ;
|
|
dDeltaIni = 0 ;
|
|
}
|
|
if ( ! DistPointCurve( ptOn, *pCopy).GetParamAtMinDistPoint( 0, dU, nFlag) || nFlag != MDPCI_NORMAL)
|
|
return false ;
|
|
if ( pCopy->GetLengthAtParam( dU, *pdLen)) {
|
|
*pdLen -= dDeltaIni ;
|
|
return true ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveIsClosed( int nId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// verifico se chiusa
|
|
return ( pCurve != nullptr && pCurve->IsClosed()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveIsFlat( int nId, Plane3d& Plane, bool bUseExtrusion, double dToler)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( &Plane == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// ne verifico la planarit�
|
|
return ( pCurve != nullptr && pCurve->IsFlat( Plane, bUseExtrusion, dToler)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveIsACircle( int nId, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW, double dToler)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico i parametri
|
|
if ( &ptCen == nullptr || &vtN == nullptr || &dRad == nullptr || &bCCW == nullptr)
|
|
return false ;
|
|
// recupero l'oggetto
|
|
IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
// analizzo tipi di curve candidabili
|
|
switch ( pGObj->GetType()) {
|
|
case CRV_ARC :
|
|
{ ICurveArc* pArc = GetCurveArc( pGObj) ;
|
|
if ( pArc->IsACircle()) {
|
|
ptCen = pArc->GetCenter() ;
|
|
vtN = pArc->GetNormVersor() ;
|
|
dRad = pArc->GetRadius() ;
|
|
bCCW = ( pArc->GetAngCenter() > 0) ;
|
|
return true ;
|
|
}
|
|
else
|
|
return false ;
|
|
}
|
|
case CRV_COMPO :
|
|
{ ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
|
|
return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ;
|
|
}
|
|
case CRV_BEZIER :
|
|
{ ICurveBezier* pBezier = GetCurveBezier( pGObj) ;
|
|
PolyArc PA ;
|
|
if ( ! pBezier->ApproxWithArcs( dToler, ANG_TOL_STD_DEG, PA))
|
|
return false ;
|
|
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
|
|
if ( IsNull( pCompo) || ! pCompo->FromPolyArc( PA))
|
|
return false ;
|
|
return pCompo->IsACircle( dToler, ptCen, vtN, dRad, bCCW) ;
|
|
}
|
|
default :
|
|
return false ;
|
|
}
|
|
|
|
return false ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveIsARectangle( int nId, Point3d& ptP, Vector3d& vtL1, Vector3d& vtL2, double dToler)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico i parametri
|
|
if ( &ptP == nullptr || &vtL1 == nullptr || &vtL2 == nullptr)
|
|
return false ;
|
|
// recupero l'oggetto
|
|
IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
// verifico sia una curva composita
|
|
if ( pGObj->GetType() != CRV_COMPO)
|
|
return false ;
|
|
// eseguo
|
|
ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
|
|
return pCompo->IsARectangle( dToler, ptP, vtL1, vtL2) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveIsATrapezoid( int nId, Point3d& ptP, Vector3d& vtB1, Vector3d& vtL1, Vector3d& vtB2, double dToler)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico i parametri
|
|
if ( &ptP == nullptr || &vtB1 == nullptr || &vtL1 == nullptr || &vtB1 == nullptr)
|
|
return false ;
|
|
// recupero l'oggetto
|
|
IGeoObj* pGObj = pGeomDB->GetGeoObj( nId) ;
|
|
if ( pGObj == nullptr)
|
|
return false ;
|
|
// verifico sia una curva composita
|
|
if ( pGObj->GetType() != CRV_COMPO)
|
|
return false ;
|
|
// eseguo
|
|
ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
|
|
return pCompo->IsATrapezoid( dToler, ptP, vtB1, vtL1, vtB2) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveAreaXY( int nId, double& dArea)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( &dArea == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// determino l'area nel piano XY
|
|
return ( pCurve != nullptr && pCurve->GetAreaXY( dArea)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveArea( int nId, Plane3d& Plane, double& dArea)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico i parametri
|
|
if ( &Plane == nullptr || &dArea == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// determino il piano medio della curva e la sua area su di esso (deve essere chiusa)
|
|
return ( pCurve != nullptr && pCurve->GetArea( Plane, dArea)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveNearestExtremityToPoint( int nId, const Point3d& ptP, bool& bStart)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// recupero quale estremo � pi� vicino al punto
|
|
return ( pCurve != nullptr && pCurve->GetNearestExtremityToPoint( ptP, bStart)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveExtrusion( int nId, int nRefId, Vector3d& vtExtr)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// ne ricavo il vettore estrusione
|
|
if ( pCurve == nullptr || ! pCurve->GetExtrusion( vtExtr))
|
|
return false ;
|
|
// gestione trasformazione ( eventuale)
|
|
return TransformVector( pGeomDB, nId, nRefId, vtExtr) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveThickness( int nId, double* pdThick)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdThick == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
// recupero lo spessore
|
|
return ( pCurve != nullptr && pCurve->GetThickness( *pdThick)) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveSelfIntersCount( int nId, int* pnCount)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pnCount == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCurve == nullptr)
|
|
return false ;
|
|
// calcolo le auto-intersezioni
|
|
SelfIntersCurve sintC( *pCurve) ;
|
|
// ne recupero il numero
|
|
*pnCount = sintC.GetIntersCount() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveMinAreaRectangleXY( int nId, int nRefId, Frame3d& frRect, double& dDimX, double& dDimY)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva
|
|
ICurve* pCurve = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
bool bOk = ( pCurve != nullptr) ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv ;
|
|
bOk = bOk && pGeomDB->GetGlobFrame( nId, frCrv) ;
|
|
// derivo la polilinea di approssimazione della curva entro la tolleranza standard
|
|
PolyLine PL ;
|
|
bOk = bOk && pCurve->ApproxWithLines( LIN_TOL_FINE, ANG_TOL_STD_DEG, APP_LINES, PL) ;
|
|
// eventuale trasformazione per riferimento di espressione
|
|
if ( bOk && nRefId == GDB_ID_ROOT)
|
|
PL.ToGlob( frCrv) ;
|
|
else if ( bOk && nRefId == GDB_ID_GRID)
|
|
PL.LocToLoc( frCrv, pGeomDB->GetGridFrame()) ;
|
|
else if ( bOk && nRefId != nId) {
|
|
Frame3d frDest ;
|
|
// nRefId pu� essere un gruppo o una entit�
|
|
if ( pGeomDB->GetGroupGlobFrame( nRefId, frDest) ||
|
|
pGeomDB->GetGlobFrame( nRefId, frDest))
|
|
PL.LocToLoc( frCrv, frDest) ;
|
|
else
|
|
bOk = false ;
|
|
}
|
|
// derivo il rettangolo in XY di area minima di questa
|
|
Point3d ptCen ;
|
|
Vector3d vtAx ;
|
|
bOk = bOk && PL.GetMinAreaRectangleXY( ptCen, vtAx, dDimX, dDimY) &&
|
|
frRect.Set( ptCen, Z_AX, vtAx) ;
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
ExeClosedCurveClassify( int nId1, int nId2)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, 0)
|
|
// recupero la prima curva
|
|
const ICurve* pCrv1 = GetCurve( pGeomDB->GetGeoObj( nId1)) ;
|
|
if ( pCrv1 == nullptr || ! pCrv1->IsClosed())
|
|
return CCREGC_NULL ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv1 ;
|
|
if ( ! pGeomDB->GetGlobFrame( nId1, frCrv1))
|
|
return CCREGC_NULL ;
|
|
// recupero la seconda curva
|
|
const ICurve* pCrv2 = GetCurve( pGeomDB->GetGeoObj( nId2)) ;
|
|
if ( pCrv2 == nullptr || ! pCrv2->IsClosed())
|
|
return CCREGC_NULL ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv2 ;
|
|
if ( ! pGeomDB->GetGlobFrame( nId2, frCrv2))
|
|
return CCREGC_NULL ;
|
|
// se riferimenti diversi, porto una copia della seconda nel riferimento della prima
|
|
const ICurve* pCrv2L = pCrv2 ;
|
|
PtrOwner<ICurve> pTmp ;
|
|
if ( ! AreSameFrame( frCrv1, frCrv2)) {
|
|
pTmp.Set( pCrv2->Clone()) ;
|
|
if ( IsNull( pTmp) || ! pTmp->LocToLoc( frCrv2, frCrv1))
|
|
return CCREGC_NULL ;
|
|
pCrv2L = pTmp ;
|
|
}
|
|
|
|
// classifico la prima curva rispetto alla seconda
|
|
IntersCurveCurve ccInt( *pCrv1, *pCrv2L) ;
|
|
return ccInt.GetRegionCurveClassification() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
ExeCurveWithRegionClassify( int nCurveId, int nRegionId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, 0)
|
|
// recupero la curva e il suo riferimento
|
|
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCurveId)) ;
|
|
if ( pCrv == nullptr)
|
|
return CRC_NULL ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv ;
|
|
if ( ! pGeomDB->GetGlobFrame( nCurveId, frCrv))
|
|
return CRC_NULL ;
|
|
// recupero la superficie FlatRegion e il suo riferimento
|
|
ISurfFlatRegion* pSfr = GetSurfFlatRegion( pGeomDB->GetGeoObj( nRegionId)) ;
|
|
if ( pSfr == nullptr)
|
|
return CRC_NULL ;
|
|
// recupero il riferimento della superficie
|
|
Frame3d frSurf ;
|
|
if ( ! pGeomDB->GetGlobFrame( nRegionId, frSurf))
|
|
return CRC_NULL ;
|
|
// se riferimenti diversi, porto una copia della curva nel riferimento della superficie
|
|
const ICurve* pCrvL = pCrv ;
|
|
PtrOwner<ICurve> pTmp ;
|
|
if ( ! AreSameFrame( frCrv, frSurf)) {
|
|
pTmp.Set( pCrv->Clone()) ;
|
|
if ( IsNull( pTmp))
|
|
return CRC_NULL ;
|
|
pTmp->LocToLoc( frCrv, frSurf) ;
|
|
pCrvL = pTmp ;
|
|
}
|
|
// classifico la curva rispetto alla regione
|
|
CRVCVECTOR vcClass ;
|
|
if ( ! pSfr->GetCurveClassification( *pCrvL, EPS_SMALL, vcClass))
|
|
return CRC_NULL ;
|
|
int nRes = CRC_NULL ;
|
|
for ( auto& cClass : vcClass) {
|
|
switch ( cClass.nClass) {
|
|
case CRVC_NULL :
|
|
return CRC_NULL ;
|
|
break ;
|
|
case CRVC_IN :
|
|
if ( nRes == CRC_NULL || nRes == CRC_IN || nRes == CRC_ON)
|
|
nRes = CRC_IN ;
|
|
else
|
|
nRes = CRC_INTERS ;
|
|
break ;
|
|
case CRVC_OUT :
|
|
if ( nRes == CRC_NULL || nRes == CRC_OUT || nRes == CRC_ON)
|
|
nRes = CRC_OUT ;
|
|
else
|
|
nRes = CRC_INTERS ;
|
|
break ;
|
|
case CRVC_ON_P :
|
|
case CRVC_ON_M :
|
|
if ( nRes == CRC_NULL)
|
|
nRes = CRC_ON ;
|
|
break ;
|
|
}
|
|
}
|
|
|
|
return nRes ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeArcRadius( int nId, double* pdRad)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdRad == nullptr)
|
|
return false ;
|
|
// recupero l'arco
|
|
const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pArc == nullptr)
|
|
return false ;
|
|
*pdRad = pArc->GetRadius() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeArcAngCenter( int nId, double* pdAngDeg)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdAngDeg == nullptr)
|
|
return false ;
|
|
// recupero l'arco
|
|
const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pArc == nullptr)
|
|
return false ;
|
|
*pdAngDeg = pArc->GetAngCenter() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeArcDeltaN( int nId, double* pdDeltaN)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( pdDeltaN == nullptr)
|
|
return false ;
|
|
// recupero l'arco
|
|
const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pArc == nullptr)
|
|
return false ;
|
|
*pdDeltaN = pArc->GetDeltaN() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeArcNormVersor( int nId, int nRefId, Vector3d& vtNorm)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero l'arco
|
|
const ICurveArc* pArc = GetCurveArc( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pArc == nullptr)
|
|
return false ;
|
|
// recupero la normale
|
|
vtNorm = pArc->GetNormVersor() ;
|
|
// gestione trasformazione ( eventuale)
|
|
return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoLength( int nId, int nSimpCrv, double& dLen)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompoCrv == nullptr)
|
|
return false ;
|
|
// recupero la curva semplice di indice richiesto
|
|
const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
|
|
if ( pSimpCrv == nullptr)
|
|
return false ;
|
|
// recupero la sua lunghezza
|
|
return pSimpCrv->GetLength( dLen) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoCenter( int nId, int nSimpCrv, int nRefId, Point3d& ptCen)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompoCrv == nullptr)
|
|
return false ;
|
|
// recupero la curva semplice di indice richiesto
|
|
const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
|
|
if ( pSimpCrv == nullptr)
|
|
return false ;
|
|
// recupero il centro
|
|
if ( ! pSimpCrv->GetCenterPoint( ptCen))
|
|
return false ;
|
|
// gestione trasformazione ( eventuale)
|
|
return TransformPoint( pGeomDB, nId, nRefId, ptCen) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoRadius( int nId, int nSimpCrv, double& dRad)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompoCrv == nullptr)
|
|
return false ;
|
|
// recupero la curva semplice di indice richiesto
|
|
const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
|
|
if ( pSimpCrv == nullptr)
|
|
return false ;
|
|
// a seconda del tipo di curva
|
|
switch ( pSimpCrv->GetType()) {
|
|
case CRV_LINE :
|
|
dRad = -1 ;
|
|
break ;
|
|
case CRV_ARC :
|
|
dRad = GetCurveArc( pSimpCrv)->GetRadius() ;
|
|
break ;
|
|
case CRV_BEZIER :
|
|
dRad = -2 ;
|
|
break ;
|
|
default :
|
|
dRad = -3 ;
|
|
break ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoAngCenter( int nId, int nSimpCrv, double& dAngCen)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompoCrv == nullptr)
|
|
return false ;
|
|
// recupero la curva semplice di indice richiesto
|
|
const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
|
|
if ( pSimpCrv == nullptr)
|
|
return false ;
|
|
// a seconda del tipo di curva
|
|
switch ( pSimpCrv->GetType()) {
|
|
case CRV_LINE :
|
|
dAngCen = 0 ;
|
|
break ;
|
|
case CRV_ARC :
|
|
dAngCen = GetCurveArc( pSimpCrv)->GetAngCenter() ;
|
|
break ;
|
|
case CRV_BEZIER :
|
|
dAngCen = 0 ;
|
|
break ;
|
|
default :
|
|
dAngCen = 0 ;
|
|
break ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoNormVersor( int nId, int nSimpCrv, int nRefId, Vector3d& vtNorm)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompoCrv = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompoCrv == nullptr)
|
|
return false ;
|
|
// recupero la curva semplice di indice richiesto
|
|
const ICurve* pSimpCrv = pCompoCrv->GetCurve( nSimpCrv) ;
|
|
if ( pSimpCrv == nullptr)
|
|
return false ;
|
|
// a seconda del tipo di curva
|
|
switch ( pSimpCrv->GetType()) {
|
|
case CRV_LINE :
|
|
vtNorm = V_NULL ;
|
|
break ;
|
|
case CRV_ARC :
|
|
vtNorm = GetCurveArc( pSimpCrv)->GetNormVersor() ;
|
|
break ;
|
|
case CRV_BEZIER :
|
|
vtNorm = V_NULL ;
|
|
break ;
|
|
default :
|
|
vtNorm = V_NULL ;
|
|
break ;
|
|
}
|
|
// gestione trasformazione ( eventuale)
|
|
return TransformVector( pGeomDB, nId, nRefId, vtNorm) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoGetTempProp( int nId, INTVECTOR& vProp, int nPropInd)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompo == nullptr)
|
|
return false ;
|
|
// recupero i valori
|
|
vProp.clear() ;
|
|
vProp.reserve( pCompo->GetCurveCount()) ;
|
|
const ICurve* pSmplCrv = pCompo->GetFirstCurve() ;
|
|
while ( pSmplCrv != nullptr) {
|
|
vProp.push_back( pSmplCrv->GetTempProp( nPropInd)) ;
|
|
pSmplCrv = pCompo->GetNextCurve() ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveCompoGetTempParam( int nId, DBLVECTOR& vParam, int nParamInd)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva composita
|
|
const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCompo == nullptr)
|
|
return false ;
|
|
// recupero i valori
|
|
vParam.clear() ;
|
|
vParam.reserve( pCompo->GetCurveCount()) ;
|
|
const ICurve* pSmplCrv = pCompo->GetFirstCurve() ;
|
|
while ( pSmplCrv != nullptr) {
|
|
vParam.push_back( pSmplCrv->GetTempParam( nParamInd)) ;
|
|
pSmplCrv = pCompo->GetNextCurve() ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
ExeShowCurveBezierControlPoints( int nCrvId, int nDestGrpId, int* pnCount)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva di Bezier
|
|
IGeoObj* pGeoObj = pGeomDB->GetGeoObj( nCrvId) ;
|
|
if ( pGeoObj == nullptr || ( pGeoObj->GetType() != CRV_BEZIER && pGeoObj->GetType() != CRV_COMPO))
|
|
return GDB_ID_NULL ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv ;
|
|
bool bOk = true ;
|
|
bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
|
|
// recupero il riferimento di destinazione
|
|
Frame3d frDest ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
|
|
if ( ! bOk)
|
|
return GDB_ID_NULL ;
|
|
int nType = pGeoObj->GetType() ;
|
|
if ( nType == CRV_COMPO) {
|
|
const ICurveComposite* pCrvCompo = GetCurveComposite( pGeoObj) ;
|
|
if ( pCrvCompo == nullptr)
|
|
return false ;
|
|
int nFirstId = -1 ;
|
|
int nCount = 0 ;
|
|
for ( int i = 0 ; i < pCrvCompo->GetCurveCount() ; ++i) {
|
|
const ICurveBezier* pCrvBezier = GetCurveBezier( pCrvCompo->GetCurve(i)) ;
|
|
if ( pCrvBezier == nullptr) {
|
|
if ( pnCount != nullptr)
|
|
*pnCount = nCount ;
|
|
return nFirstId ;
|
|
}
|
|
int nDeg = pCrvBezier->GetDegree() ;
|
|
//bool bRat = pCrvBezier->IsRational() ;
|
|
for ( int i = 0 ; i < nDeg + 1 ; ++i) {
|
|
IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
|
|
//if ( ! bRat)
|
|
// pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
|
|
//else
|
|
// pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
|
|
pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
|
|
pGeoPt->LocToLoc( frCrv, frDest) ;
|
|
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
|
|
if ( nFirstId == GDB_ID_NULL)
|
|
nFirstId = nId ;
|
|
if ( nId != GDB_ID_NULL)
|
|
++nCount ;
|
|
}
|
|
}
|
|
// restituisco i risultati
|
|
if ( pnCount != nullptr)
|
|
*pnCount = nCount ;
|
|
return nFirstId ;
|
|
}
|
|
else if ( nType == CRV_BEZIER) {
|
|
const ICurveBezier* pCrvBezier = GetCurveBezier( pGeoObj) ;
|
|
if ( pCrvBezier == nullptr)
|
|
return false ;
|
|
int nDeg = pCrvBezier->GetDegree() ;
|
|
//bool bRat = pCrvBezier->IsRational() ;
|
|
int nFirstId = -1 ;
|
|
int nCount = 0 ;
|
|
for ( int i = 0 ; i < nDeg + 1 ; ++i) {
|
|
IGeoPoint3d* pGeoPt( CreateGeoPoint3d()) ;
|
|
//if ( ! bRat)
|
|
// pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
|
|
//else
|
|
// pGeoPt->Set( pCrvBezier->GetControlPoint( i) * pCrvBezier->GetControlWeight( i)) ;
|
|
pGeoPt->Set( pCrvBezier->GetControlPoint( i)) ;
|
|
pGeoPt->LocToLoc( frCrv, frDest) ;
|
|
int nId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pGeoPt) ;
|
|
if ( nFirstId == GDB_ID_NULL)
|
|
nFirstId = nId ;
|
|
if ( nId != GDB_ID_NULL)
|
|
++nCount ;
|
|
}
|
|
// restituisco i risultati
|
|
if ( pnCount != nullptr)
|
|
*pnCount = nCount ;
|
|
return nFirstId ;
|
|
}
|
|
else
|
|
return GDB_ID_NULL ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeCurveMaxOffset( int nId, double& dMaxOffset)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico il parametro
|
|
if ( &dMaxOffset == nullptr)
|
|
return false ;
|
|
// recupero la curva
|
|
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nId)) ;
|
|
if ( pCrv == nullptr)
|
|
return false ;
|
|
return CalcCurveLimitOffset( *pCrv, dMaxOffset) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
ExeCopyCompoSubCurve( int nCrvId, int nSubCrvToCopy, int nDestGrpId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva compo
|
|
const ICurveComposite* pCompo = GetCurveComposite( pGeomDB->GetGeoObj( nCrvId)) ;
|
|
if ( pCompo == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv ;
|
|
bool bOk = true ;
|
|
bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
|
|
// recupero il riferimento di destinazione
|
|
Frame3d frDest ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
|
|
if ( ! bOk)
|
|
return GDB_ID_NULL ;
|
|
|
|
// creo una copia e la porto nel frame della destinazione
|
|
const ICurve* pSubCrv = pCompo->GetCurve( nSubCrvToCopy) ;
|
|
if ( pSubCrv == nullptr)
|
|
return GDB_ID_NULL ;
|
|
ICurve* pSubCrvCopy = pSubCrv->Clone() ;
|
|
if ( pSubCrvCopy == nullptr)
|
|
return GDB_ID_NULL ;
|
|
pSubCrvCopy->LocToLoc( frCrv, frDest) ;
|
|
int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtCopyCompoSubCurve(" + IdToString( nCrvId) + "," +
|
|
ToString( nSubCrvToCopy) + "," +
|
|
IdToString( nDestGrpId) + ")" +
|
|
" -- Id=" + ToString( nSubCrvId) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco l'identificativo della nuova entità
|
|
return nSubCrvId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
ExeCopyParamRange( int nCrvId, double dUStart, double dUEnd, int nDestGrpId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero la curva
|
|
const ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nCrvId)) ;
|
|
// recupero il riferimento della curva
|
|
Frame3d frCrv ;
|
|
bool bOk = true ;
|
|
bOk = bOk && pGeomDB->GetGlobFrame( nCrvId, frCrv) ;
|
|
// recupero il riferimento di destinazione
|
|
Frame3d frDest ;
|
|
bOk = bOk && pGeomDB->GetGroupGlobFrame( nDestGrpId, frDest) ;
|
|
if ( ! bOk)
|
|
return GDB_ID_NULL ;
|
|
|
|
// creo una copia e la porto nel frame della destinazione
|
|
ICurve* pSubCrvCopy = pCrv->CopyParamRange( dUStart, dUEnd) ;
|
|
if ( pSubCrvCopy == nullptr)
|
|
return GDB_ID_NULL ;
|
|
pSubCrvCopy->LocToLoc( frCrv, frDest) ;
|
|
int nSubCrvId = pGeomDB->AddGeoObj( GDB_ID_NULL, nDestGrpId, pSubCrvCopy) ;
|
|
ExeSetModified() ;
|
|
|
|
return nSubCrvId ;
|
|
} |