Riccardo Elitropi
9b5995a073
- piccole migliorie per PocketingNT - migliorato il controllo per nStep alla funzione AddLinearMove in Operation.
548 lines
17 KiB
C++
548 lines
17 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2016-2016
|
|
//----------------------------------------------------------------------------
|
|
// File : Operation.cpp Data : 29.05.16 Versione : 1.6r7
|
|
// Contenuto : Implementazione gestione operazioni per CL.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 29.05.16 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "DllMain.h"
|
|
#include "Operation.h"
|
|
#include "MachMgr.h"
|
|
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EGkCurveLine.h"
|
|
#include "/EgtDev/Include/EGkCurveArc.h"
|
|
#include "/EgtDev/Include/EGkCurveComposite.h"
|
|
#include "/EgtDev/Include/EGkGeomDB.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetPathId( int nPathId)
|
|
{
|
|
m_nPathId = nPathId ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetToolDir( const Vector3d& vtDir)
|
|
{
|
|
m_vtTool = vtDir ;
|
|
return ( m_vtTool.Normalize()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetCorrDir( const Vector3d& vtDir)
|
|
{
|
|
m_vtCorr = vtDir ;
|
|
return ( ! m_vtCorr.IsSmall()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetAuxDir( const Vector3d& vtDir)
|
|
{
|
|
m_vtAux = vtDir ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetCorrAuxDir( const Vector3d& vtDir)
|
|
{
|
|
m_vtCorr = vtDir ;
|
|
m_vtAux = vtDir ;
|
|
return ( ! m_vtCorr.IsSmall()) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetFeed( double dFeed)
|
|
{
|
|
m_dFeed = dFeed ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetFlag( int nFlag)
|
|
{
|
|
m_nFlag = nFlag ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetFlagOnLastMove( int nFlag)
|
|
{
|
|
int nLastEntId = m_pGeomDB->GetLastInGroup( m_nPathId) ;
|
|
CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nLastEntId)) ;
|
|
if ( pCamData == nullptr)
|
|
return false ;
|
|
pCamData->SetFlag( nFlag) ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetFlag2( int nFlag2)
|
|
{
|
|
m_nFlag2 = nFlag2 ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::SetIndex( int nIndex)
|
|
{
|
|
m_nIndex = nIndex ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddRapidStart( const Point3d& ptP)
|
|
{
|
|
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// verifico di essere in uno stato valido per inizio
|
|
if ( m_vtTool.IsSmall())
|
|
return GDB_ID_NULL ;
|
|
// creo oggetto punto per DB geometrico
|
|
PtrOwner<IGeoPoint3d> pGP( CreateGeoPoint3d()) ;
|
|
if ( IsNull( pGP))
|
|
return GDB_ID_NULL ;
|
|
// assegno le coordinate del punto
|
|
pGP->Set( ptP) ;
|
|
// inserisco l'oggetto nel DB geometrico
|
|
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pGP)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// creo oggetto dati Cam
|
|
PtrOwner<CamData> pCam( new( nothrow) CamData) ;
|
|
if ( IsNull( pCam))
|
|
return GDB_ID_NULL ;
|
|
// assegno valori
|
|
pCam->SetMoveType( 0) ;
|
|
pCam->SetToolDir( m_vtTool) ;
|
|
pCam->SetCorrDir( m_vtCorr) ;
|
|
pCam->SetAuxDir( m_vtAux) ;
|
|
pCam->SetEndPoint( ptP) ;
|
|
pCam->SetFeed( 0) ;
|
|
pCam->SetFlag( m_nFlag) ;
|
|
pCam->SetFlag2( m_nFlag2) ;
|
|
pCam->SetIndex( m_nIndex) ;
|
|
// associo questo oggetto a quello geometrico
|
|
m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
|
|
// salvo la posizione corrente
|
|
m_bCurr = true ;
|
|
m_ptCurr = ptP ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddRapidStart( const Point3d& ptP, const string& sName)
|
|
{
|
|
int nId = AddRapidStart( ptP) ;
|
|
if ( nId != GDB_ID_NULL)
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddRapidMove( const Point3d& ptP)
|
|
{
|
|
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// verifico di essere in uno stato valido per un movimento in rapido
|
|
if ( ! m_bCurr || m_vtTool.IsSmall())
|
|
return GDB_ID_NULL ;
|
|
// creo oggetto linea per DB geometrico
|
|
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
|
|
if ( IsNull( pLine))
|
|
return GDB_ID_NULL ;
|
|
// assegno le coordinate degli estremi
|
|
if ( ! pLine->Set( m_ptCurr, ptP))
|
|
return GDB_ID_NULL ;
|
|
// inserisco l'oggetto nel DB geometrico
|
|
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pLine)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// creo oggetto dati Cam
|
|
PtrOwner<CamData> pCam( new( nothrow) CamData) ;
|
|
if ( IsNull( pCam))
|
|
return GDB_ID_NULL ;
|
|
// assegno valori
|
|
pCam->SetMoveType( 0) ;
|
|
pCam->SetToolDir( m_vtTool) ;
|
|
pCam->SetCorrDir( m_vtCorr) ;
|
|
pCam->SetAuxDir( m_vtAux) ;
|
|
pCam->SetEndPoint( ptP) ;
|
|
pCam->SetFeed( 0) ;
|
|
pCam->SetFlag( m_nFlag) ;
|
|
pCam->SetFlag2( m_nFlag2) ;
|
|
pCam->SetIndex( m_nIndex) ;
|
|
// associo questo oggetto a quello geometrico
|
|
m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
|
|
// salvo la posizione corrente
|
|
m_ptCurr = ptP ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddRapidMove( const Point3d& ptP, const string& sName)
|
|
{
|
|
int nId = AddRapidMove( ptP) ;
|
|
if ( nId != GDB_ID_NULL)
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddRapidMove( const Point3d& ptP, bool bSplit)
|
|
{
|
|
// se non richiesta spezzatura con massima lunghezza, emissione normale
|
|
if ( ! NeedSplit( bSplit))
|
|
return AddRapidMove( ptP) ;
|
|
// altrimenti opportuna spezzatura
|
|
Point3d ptS ;
|
|
if ( ! GetCurrPos( ptS))
|
|
return GDB_ID_NULL ;
|
|
double dLen = Dist( ptS, ptP) ;
|
|
double dStep = GetMaxSplitLen( true, false) ;
|
|
int nStep = int( dLen / dStep + 0.999) ;
|
|
int nFirstId = GDB_ID_NULL ;
|
|
for ( int i = 1 ; i <= nStep ; ++ i) {
|
|
int nId = AddRapidMove( Media( ptS, ptP, i * 1.0 / nStep)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
if ( nFirstId == GDB_ID_NULL)
|
|
nFirstId = nId ;
|
|
SetFlag( 0) ;
|
|
SetFlag2( 0) ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddRapidMove( const Point3d& ptP, bool bSplit, const string& sName)
|
|
{
|
|
int nFirstId = AddRapidMove( ptP, bSplit) ;
|
|
int nId = nFirstId ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddLinearMove( const Point3d& ptP)
|
|
{
|
|
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// verifico di essere in uno stato valido per un movimento lineare
|
|
if ( ! m_bCurr || m_vtTool.IsSmall()) {
|
|
LOG_ERROR( GetEMkLogger(), "Error on LinearMove : Curr or ToolDir")
|
|
return GDB_ID_NULL ;
|
|
}
|
|
// se feed nulla, assegno il minimo e lo segnalo
|
|
if ( m_dFeed < FEED_MIN) {
|
|
m_dFeed = FEED_MIN ;
|
|
LOG_WARN( GetEMkLogger(), "Warning on LinearMove : Min Feed")
|
|
}
|
|
// creo oggetto linea per DB geometrico
|
|
PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
|
|
if ( IsNull( pLine))
|
|
return GDB_ID_NULL ;
|
|
// assegno le coordinate degli estremi
|
|
if ( ! pLine->Set( m_ptCurr, ptP))
|
|
return GDB_ID_NULL ;
|
|
// inserisco l'oggetto nel DB geometrico
|
|
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pLine)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// creo oggetto dati Cam
|
|
PtrOwner<CamData> pCam( new( nothrow) CamData) ;
|
|
if ( IsNull( pCam))
|
|
return GDB_ID_NULL ;
|
|
// assegno valori
|
|
pCam->SetMoveType( 1) ;
|
|
pCam->SetToolDir( m_vtTool) ;
|
|
pCam->SetCorrDir( m_vtCorr) ;
|
|
pCam->SetAuxDir( m_vtAux) ;
|
|
pCam->SetEndPoint( ptP) ;
|
|
pCam->SetFeed( m_dFeed) ;
|
|
pCam->SetFlag( m_nFlag) ;
|
|
pCam->SetFlag2( m_nFlag2) ;
|
|
pCam->SetIndex( m_nIndex) ;
|
|
// associo questo oggetto a quello geometrico
|
|
m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
|
|
// salvo la posizione corrente
|
|
m_ptCurr = ptP ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddLinearMove( const Point3d& ptP, const string& sName)
|
|
{
|
|
int nId = AddLinearMove( ptP) ;
|
|
if ( nId != GDB_ID_NULL)
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddLinearMove( const Point3d& ptP, bool bSplit)
|
|
{
|
|
// se non richiesta spezzatura con massima lunghezza, emissione normale
|
|
if ( ! NeedSplit( bSplit))
|
|
return AddLinearMove( ptP) ;
|
|
// altrimenti opportuna spezzatura
|
|
Point3d ptS ;
|
|
if ( ! GetCurrPos( ptS))
|
|
return GDB_ID_NULL ;
|
|
double dLen = Dist( ptS, ptP) ;
|
|
double dStep = GetMaxSplitLen( true, true) ;
|
|
int nStep = int( ceil( ( dLen - EPS_ZERO) / dStep)) ;
|
|
int nFirstId = GDB_ID_NULL ;
|
|
for ( int i = 1 ; i <= nStep ; ++ i) {
|
|
int nId = AddLinearMove( Media( ptS, ptP, i * 1.0 / nStep)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
if ( nFirstId == GDB_ID_NULL)
|
|
nFirstId = nId ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddLinearMove( const Point3d& ptP, bool bSplit, const string& sName)
|
|
{
|
|
int nFirstId = AddLinearMove( ptP, bSplit) ;
|
|
int nId = nFirstId ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN)
|
|
{
|
|
if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// verifico di essere in uno stato valido per un movimento arco
|
|
if ( ! m_bCurr || m_vtTool.IsSmall()) {
|
|
LOG_ERROR( GetEMkLogger(), "Error on ArcMove : Curr or ToolDir")
|
|
return GDB_ID_NULL ;
|
|
}
|
|
// se feed nulla, assegno il minimo e lo segnalo
|
|
if ( m_dFeed < FEED_MIN) {
|
|
m_dFeed = FEED_MIN ;
|
|
LOG_WARN( GetEMkLogger(), "Warning on ArcMove : Min Feed")
|
|
}
|
|
// creo oggetto arco per DB geometrico
|
|
PtrOwner<ICurveArc> pArc( CreateCurveArc()) ;
|
|
if ( IsNull( pArc))
|
|
return GDB_ID_NULL ;
|
|
// verifico normale arco rispetto a versore utensile, ed eventualmente modifico opportunamente
|
|
Vector3d vtMyN = vtN ;
|
|
double dMyAngCen = dAngCen ;
|
|
if ( vtMyN * m_vtTool < - EPS_ZERO) {
|
|
vtMyN = - vtMyN ;
|
|
dMyAngCen = - dMyAngCen ;
|
|
}
|
|
// assegno i dati dell'arco
|
|
double dDeltaZ = ( ptP - m_ptCurr) * vtMyN ;
|
|
if ( ! pArc->SetCPAN( ptCen, m_ptCurr, dMyAngCen, dDeltaZ, vtMyN))
|
|
return GDB_ID_NULL ;
|
|
Point3d ptFin ;
|
|
if ( ! pArc->GetEndPoint( ptFin) || ! AreSamePointApprox( ptFin, ptP))
|
|
return GDB_ID_NULL ;
|
|
int nMove = ( dMyAngCen > 0 ? 3 : 2) ;
|
|
// inserisco l'oggetto nel DB geometrico
|
|
int nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, m_nPathId, Release( pArc)) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// creo oggetto dati Cam
|
|
PtrOwner<CamData> pCam( new( nothrow) CamData) ;
|
|
if ( IsNull( pCam))
|
|
return GDB_ID_NULL ;
|
|
// assegno valori
|
|
pCam->SetMoveType( nMove) ;
|
|
pCam->SetToolDir( m_vtTool) ;
|
|
pCam->SetCorrDir( m_vtCorr) ;
|
|
pCam->SetAuxDir( m_vtAux) ;
|
|
pCam->SetEndPoint( ptP) ;
|
|
pCam->SetCenter( ptCen) ;
|
|
pCam->SetAngCen( dMyAngCen) ;
|
|
pCam->SetDeltaN( dDeltaZ) ;
|
|
pCam->SetNormDir( vtMyN) ;
|
|
pCam->SetFeed( m_dFeed) ;
|
|
pCam->SetFlag( m_nFlag) ;
|
|
pCam->SetFlag2( m_nFlag2) ;
|
|
pCam->SetIndex( m_nIndex) ;
|
|
// associo questo oggetto a quello geometrico
|
|
m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
|
|
// salvo la posizione corrente
|
|
m_ptCurr = ptP ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN, const string& sName)
|
|
{
|
|
int nId = AddArcMove( ptP, ptCen, dAngCen, vtN) ;
|
|
if ( nId != GDB_ID_NULL)
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
return nId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddCurveMove( const ICurve* pCrv)
|
|
{
|
|
// verifico che la curva esista
|
|
if ( pCrv == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// se linea
|
|
if ( pCrv->GetType() == CRV_LINE) {
|
|
const ICurveLine* pLine = GetCurveLine( pCrv) ;
|
|
Point3d ptP3 = pLine->GetEnd() ;
|
|
return AddLinearMove( ptP3) ;
|
|
}
|
|
// se arco semplice
|
|
else if ( pCrv->GetType() == CRV_ARC && abs( GetCurveArc( pCrv)->GetAngCenter()) < MAX_ANG_CEN) {
|
|
const ICurveArc* pArc = GetCurveArc( pCrv) ;
|
|
Point3d ptCen = pArc->GetCenter() ;
|
|
double dAngCen = pArc->GetAngCenter() ;
|
|
Vector3d vtN = pArc->GetNormVersor() ;
|
|
Point3d ptP3 ;
|
|
pArc->GetEndPoint( ptP3) ;
|
|
return AddArcMove( ptP3, ptCen, dAngCen, vtN) ;
|
|
}
|
|
// se arco o curva composita
|
|
else if ( pCrv->GetType() == CRV_ARC || pCrv->GetType() == CRV_COMPO) {
|
|
// in ogni caso, converto in archi e rette
|
|
PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
|
|
if ( ! pCompo->AddCurve( *pCrv))
|
|
return GDB_ID_NULL ;
|
|
// verifico archi
|
|
VerifyArcs( pCompo) ;
|
|
// emetto curve componenti
|
|
int nFirstId = GDB_ID_NULL ;
|
|
const ICurve* pCrv = pCompo->GetFirstCurve() ;
|
|
while ( pCrv != nullptr) {
|
|
if ( pCrv->GetType() == CRV_LINE) {
|
|
const ICurveLine* pLine = GetCurveLine( pCrv) ;
|
|
Point3d ptP3 = pLine->GetEnd() ;
|
|
int nId = AddLinearMove( ptP3) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
if ( nFirstId == GDB_ID_NULL)
|
|
nFirstId = nId ;
|
|
}
|
|
else if ( pCrv->GetType() == CRV_ARC) {
|
|
const ICurveArc* pArc = GetCurveArc( pCrv) ;
|
|
Point3d ptCen = pArc->GetCenter() ;
|
|
double dAngCen = pArc->GetAngCenter() ;
|
|
Vector3d vtN = pArc->GetNormVersor() ;
|
|
Point3d ptP3 ;
|
|
pArc->GetEndPoint( ptP3) ;
|
|
int nId = AddArcMove( ptP3, ptCen, dAngCen, vtN) ;
|
|
if ( nId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
if ( nFirstId == GDB_ID_NULL)
|
|
nFirstId = nId ;
|
|
}
|
|
else
|
|
return GDB_ID_NULL ;
|
|
pCrv = pCompo->GetNextCurve() ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
// altre curve non ammesse
|
|
else
|
|
return GDB_ID_NULL ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddCurveMove( const ICurve* pCrv, const string& sName)
|
|
{
|
|
int nFirstId = AddCurveMove( pCrv) ;
|
|
int nId = nFirstId ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddCurveMove( const ICurve* pCrv, bool bSplit)
|
|
{
|
|
// se non richiesta spezzatura, emissione normale
|
|
if ( ! bSplit)
|
|
return AddCurveMove( pCrv) ;
|
|
// altrimenti opportuna spezzatura
|
|
PtrOwner<ICurveComposite> pCompo ;
|
|
if ( ! pCompo.Set( ConvertCurveToComposite( pCrv->Clone())) || ! ApproxWithLines( pCompo))
|
|
return false ;
|
|
return AddCurveMove( pCompo) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
int
|
|
Operation::AddCurveMove( const ICurve* pCrv, bool bSplit, const string& sName)
|
|
{
|
|
int nFirstId = AddCurveMove( pCrv, bSplit) ;
|
|
int nId = nFirstId ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
m_pGeomDB->SetName( nId, sName) ;
|
|
nId = m_pGeomDB->GetNext( nId) ;
|
|
}
|
|
return nFirstId ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Operation::ResetMoveData( void)
|
|
{
|
|
m_bCurr = false ;
|
|
m_ptCurr = ORIG ;
|
|
m_vtTool = V_NULL ;
|
|
m_vtCorr = V_NULL ;
|
|
m_vtAux = V_NULL ;
|
|
m_dFeed = 0 ;
|
|
m_nFlag = 0 ;
|
|
m_nFlag2 = 0 ;
|
|
m_nIndex = 0 ;
|
|
return true ;
|
|
}
|