EgtGeomKernel 1.5e4 :
- aggiunte diverse modalità di costruzione e modifica degli archi - i comandi TSC sono stati ampliati con queste nuove modalità.
This commit is contained in:
Dario Sassi
+365
-49
@@ -86,12 +86,144 @@ CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per circonferenza completa
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad)
|
||||
{
|
||||
// assegno e calcolo i dati
|
||||
m_PtCen = ptCen ;
|
||||
m_VtN = vtN ;
|
||||
Frame3d frF ;
|
||||
if ( ! frF.Set( ORIG, vtN))
|
||||
return false ;
|
||||
m_VtS = frF.VersX() ;
|
||||
m_dRad = dRad ;
|
||||
m_dAngCenDeg = 360 ;
|
||||
m_dDeltaN = 0 ;
|
||||
m_nStatus = TO_VERIFY ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per arco di circonferenza nel piano XY
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::SetXY( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ)
|
||||
{
|
||||
// assegno e calcolo i dati
|
||||
m_PtCen = ptCen ;
|
||||
m_VtN = Z_AX ;
|
||||
m_VtS.FromPolar( 1, dAngIniDeg) ;
|
||||
m_dRad = dRad ;
|
||||
m_dAngCenDeg = dAngCenDeg ;
|
||||
m_dDeltaN = dDeltaZ ;
|
||||
m_nStatus = TO_VERIFY ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per circonferenza completa nel piano XY
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::SetXY( const Point3d& ptCen, double dRad)
|
||||
{
|
||||
// assegno e calcolo i dati
|
||||
m_PtCen = ptCen ;
|
||||
m_VtN = Z_AX ;
|
||||
m_VtS = X_AX ;
|
||||
m_dRad = dRad ;
|
||||
m_dAngCenDeg = 360 ;
|
||||
m_dDeltaN = 0 ;
|
||||
m_nStatus = TO_VERIFY ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per arco di circonf. o circonferenza completa per 3 Punti
|
||||
// ( algoritmo da Comp. Geom. di Faux e Pratt pagg. 67 e 68 )
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc)
|
||||
{
|
||||
// arco non ancora definito correttamente
|
||||
m_nStatus = ERR ;
|
||||
|
||||
// vettori dal primo punto agli altri due
|
||||
Vector3d vtA = ptOther - ptStart ;
|
||||
Vector3d vtB = ptEnd - ptStart ;
|
||||
// calcolo del versore normale
|
||||
m_VtN = vtA ^ vtB ;
|
||||
double dNSqLen = m_VtN.SqLen() ;
|
||||
// se i punti sono praticamente allineati non si può calcolare la circonferenza
|
||||
if ( ! m_VtN.Normalize( EPS_ZERO))
|
||||
return false ;
|
||||
// calcolo del centro
|
||||
m_PtCen = ptStart + ( vtB.SqLen() * ( vtA.SqLen() - vtA * vtB) * vtA +
|
||||
vtA.SqLen() * ( vtB.SqLen() - vtA * vtB) * vtB) / ( 2 * dNSqLen) ;
|
||||
// calcolo del versore start e del raggio
|
||||
m_VtS = ptStart - m_PtCen ;
|
||||
m_dRad = m_VtS.Len() ;
|
||||
if ( m_dRad < EPS_SMALL)
|
||||
return false ;
|
||||
m_VtS /= m_dRad ;
|
||||
// calcolo dell'angolo al centro
|
||||
if ( bCirc)
|
||||
m_dAngCenDeg = 360 ;
|
||||
else {
|
||||
// calcolo dell'angolo di rotazione attorno al centro dal primo al secondo punto
|
||||
bool bDet1 ;
|
||||
double dAng1Deg ;
|
||||
if ( ! m_VtS.GetRotation( ( ptOther - m_PtCen), m_VtN, dAng1Deg, bDet1) || ! bDet1)
|
||||
return false ;
|
||||
// calcolo dell'angolo di rotazione attorno al centro dal primo al terzo punto
|
||||
bool bDet2 ;
|
||||
double dAng2Deg ;
|
||||
if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng2Deg, bDet2) || ! bDet2)
|
||||
return false ;
|
||||
// deduzione dell'angolo al centro
|
||||
// se uno dei due angoli è nullo, errore
|
||||
if ( fabs( dAng1Deg) < EPS_ANG_SMALL || fabs( dAng2Deg) < EPS_ANG_SMALL)
|
||||
return false ;
|
||||
// se i due angoli hanno lo stesso segno e Ang1 è minore di Ang2 in modulo
|
||||
else if ( dAng1Deg * dAng2Deg > 0 && fabs( dAng1Deg) < fabs( dAng2Deg))
|
||||
m_dAngCenDeg = dAng2Deg ;
|
||||
// altrimenti hanno segno opposto oppure Ang1 è maggiore di Ang2 in modulo
|
||||
else
|
||||
m_dAngCenDeg = - _copysign( 360, dAng2Deg) + dAng2Deg ;
|
||||
}
|
||||
// non c'è DeltaN
|
||||
m_dDeltaN = 0 ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per arco di circonf. definito dagli estremi, versore normale e bulge
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge)
|
||||
CurveArc::Set2PNB( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge)
|
||||
{
|
||||
// arco non ancora definito correttamente
|
||||
m_nStatus = ERR ;
|
||||
|
||||
// versore normale
|
||||
m_VtN = vtN ;
|
||||
if ( ! m_VtN.Normalize())
|
||||
@@ -132,68 +264,146 @@ CurveArc::Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN,
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per arco di circonferenza nel piano XY
|
||||
// Set per arco di circonferenza nel piano XY con ptStart, ptEnd, dirStart
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Set( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ)
|
||||
CurveArc::Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg)
|
||||
{
|
||||
// assegno e calcolo i dati
|
||||
m_PtCen = ptCen ;
|
||||
m_VtN = Z_AX ;
|
||||
m_VtS.FromPolar( 1, dAngIniDeg) ;
|
||||
m_dRad = dRad ;
|
||||
m_dAngCenDeg = dAngCenDeg ;
|
||||
m_dDeltaN = dDeltaZ ;
|
||||
m_nStatus = TO_VERIFY ;
|
||||
// arco non ancora definito correttamente
|
||||
m_nStatus = ERR ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per circonferenza completa
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Set( const Point3d& ptCen, const Vector3d& vtN, double dRad)
|
||||
{
|
||||
// assegno e calcolo i dati
|
||||
m_PtCen = ptCen ;
|
||||
m_VtN = vtN ;
|
||||
Frame3d frF ;
|
||||
if ( ! frF.Set( ORIG, vtN))
|
||||
// vettore tangente iniziale ( nel piano XY)
|
||||
Vector3d vtA ;
|
||||
vtA.FromPolar( 1, dDirStartDeg) ;
|
||||
// vettore da inizio a fine ( nel piano XY)
|
||||
Vector3d vtB = ptEnd - ptStart ;
|
||||
vtB.z = 0 ;
|
||||
// calcolo del versore normale
|
||||
m_VtN = vtA ^ vtB ;
|
||||
double dNSqLen = m_VtN.SqLen() ;
|
||||
// se tangente e punti sono praticamente allineati non si può calcolare la circonferenza
|
||||
if ( ! m_VtN.Normalize( EPS_ZERO))
|
||||
return false ;
|
||||
m_VtS = frF.VersX() ;
|
||||
m_dRad = dRad ;
|
||||
m_dAngCenDeg = 360 ;
|
||||
m_dDeltaN = 0 ;
|
||||
m_nStatus = TO_VERIFY ;
|
||||
// calcolo del centro
|
||||
m_PtCen = ptStart + vtB.SqLen() * ( vtB - ( vtA * vtB) * vtA) / ( 2 * dNSqLen) ;
|
||||
// calcolo del versore start e del raggio
|
||||
m_VtS = ptStart - m_PtCen ;
|
||||
m_dRad = m_VtS.Len() ;
|
||||
if ( m_dRad < EPS_SMALL)
|
||||
return false ;
|
||||
m_VtS /= m_dRad ;
|
||||
// calcolo dell'angolo al centro
|
||||
// angolo di rotazione da start a end
|
||||
bool bDet1 ;
|
||||
double dAng1Deg ;
|
||||
if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, dAng1Deg, bDet1) || ! bDet1)
|
||||
return false ;
|
||||
// poichè il senso di rotazione è sempre CCW, se l'angolo è negativo prendo il suo complemento al giro
|
||||
if ( dAng1Deg < 0)
|
||||
m_dAngCenDeg = ANG_FULL + dAng1Deg ;
|
||||
else
|
||||
m_dAngCenDeg = dAng1Deg ;
|
||||
// DeltaN
|
||||
m_dDeltaN = ( ptEnd.z - ptStart.z) * m_VtN.z ;
|
||||
|
||||
// se normale con Z negativa, inverto senza modificare la geometria
|
||||
if ( m_VtN.z < 0) {
|
||||
m_VtN *= - 1 ;
|
||||
m_dAngCenDeg *= - 1 ;
|
||||
m_dDeltaN *= - 1 ;
|
||||
}
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per circonferenza completa nel piano XY
|
||||
// Set per arco di circonferenza nel piano XY con ptStart, ptEnd, dRad, bCCW
|
||||
// ( si suppone |dAngCenDeg| <= 180deg)
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Set( const Point3d& ptCen, double dRad)
|
||||
CurveArc::Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bool bCCW)
|
||||
{
|
||||
// assegno e calcolo i dati
|
||||
m_PtCen = ptCen ;
|
||||
// arco non ancora definito correttamente
|
||||
m_nStatus = ERR ;
|
||||
|
||||
// il piano dell'arco coincide con XY
|
||||
m_VtN = Z_AX ;
|
||||
m_VtS = X_AX ;
|
||||
m_dDeltaN = ptEnd.z - ptStart.z ;
|
||||
// semi-vettore da inizio a fine
|
||||
Vector3d vtA = 0.5 * ( ptEnd - ptStart) ;
|
||||
vtA.z = 0 ;
|
||||
double dLenA = vtA.Len() ;
|
||||
if ( dLenA < EPS_ZERO || dLenA > ( dRad + EPS_ZERO))
|
||||
return false ;
|
||||
// distanza del centro dalla corda tra inizio e fine
|
||||
double dLenH ;
|
||||
if ( dLenA > ( dRad - EPS_ZERO))
|
||||
dLenH = 0 ;
|
||||
else
|
||||
dLenH= sqrt( dRad * dRad - dLenA * dLenA) ;
|
||||
// versore dal punto medio della corda al centro
|
||||
Vector3d vtH = vtA / dLenA ;
|
||||
vtH.Rotate( Z_AX, 0, ( bCCW ? 1 : -1)) ;
|
||||
// calcolo del centro
|
||||
m_PtCen = ptStart + vtA + vtH * dLenH ;
|
||||
// assegno il raggio
|
||||
if ( dRad < EPS_ZERO)
|
||||
return false ;
|
||||
m_dRad = dRad ;
|
||||
m_dAngCenDeg = 360 ;
|
||||
m_dDeltaN = 0 ;
|
||||
m_nStatus = TO_VERIFY ;
|
||||
// calcolo il versore di start
|
||||
m_VtS = ( ptStart - m_PtCen) / m_dRad ;
|
||||
// calcolo l'angolo al centro
|
||||
bool bDet ;
|
||||
if ( ! m_VtS.GetRotation( ( ptEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet) || ! bDet)
|
||||
return false ;
|
||||
// quando è 180deg il segno è determinato solo dal senso
|
||||
if ( fabs( m_dAngCenDeg - ANG_STRAIGHT) < 10 * EPS_ANG_SMALL &&
|
||||
( ( bCCW && m_dAngCenDeg < 0) ||
|
||||
( ! bCCW && m_dAngCenDeg > 0)))
|
||||
m_dAngCenDeg = - m_dAngCenDeg ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Set per arco di circonferenza nel piano XY con ptCen, ptStart, ptNearEnd
|
||||
// ( si suppone |dAngCenDeg| <= 180deg)
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& ptNearEnd)
|
||||
{
|
||||
// arco non ancora definito correttamente
|
||||
m_nStatus = ERR ;
|
||||
|
||||
// il piano dell'arco coincide con XY
|
||||
m_VtN = Z_AX ;
|
||||
m_dDeltaN = ptNearEnd.z - ptStart.z ;
|
||||
// assegno il centro
|
||||
m_PtCen = ptCen ;
|
||||
m_PtCen.z = ptStart.z ;
|
||||
// assegno il versore iniziale e il raggio
|
||||
m_VtS = ptStart - m_PtCen ;
|
||||
m_dRad = m_VtS.Len() ;
|
||||
if ( m_dRad < EPS_ZERO)
|
||||
return false ;
|
||||
m_VtS /= m_dRad ;
|
||||
// calcolo l'angolo al centro (la funzione trova sempre il più piccolo)
|
||||
bool bDet ;
|
||||
if ( ! m_VtS.GetRotation( ( ptNearEnd - m_PtCen), m_VtN, m_dAngCenDeg, bDet) || ! bDet)
|
||||
return false ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
@@ -253,17 +463,16 @@ bool
|
||||
CurveArc::Dump( string& sOut, const char* szNewLine) const
|
||||
{
|
||||
// parametri : punti iniziale e finale
|
||||
sOut += "C(" + ToString( m_PtCen, 3) + ") " ;
|
||||
sOut += "VN(" + ToString( m_VtN, 6) + ") " ;
|
||||
sOut += "R=" + ToString( m_dRad, 3) + szNewLine ;
|
||||
sOut += "VS(" + ToString( m_VtS, 6) + ") " ;
|
||||
sOut += "Ac=" + ToString( m_dAngCenDeg, 3) + " " ;
|
||||
sOut += "Dn=" + ToString( m_dDeltaN, 3) + szNewLine ;
|
||||
sOut += "C(" + ToString( m_PtCen, 3) + ") " + szNewLine ;
|
||||
sOut += "VN(" + ToString( m_VtN, 6) + ") " + szNewLine ;
|
||||
sOut += "VS(" + ToString( m_VtS, 6) + ") " + szNewLine ;
|
||||
sOut += "R=" + ToString( m_dRad, 3) ;
|
||||
sOut += " Ac=" + ToString( m_dAngCenDeg, 3) ;
|
||||
sOut += " Dn=" + ToString( m_dDeltaN, 3) + szNewLine ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
int
|
||||
CurveArc::GetNgeId( void) const
|
||||
@@ -554,7 +763,7 @@ CurveArc::Invert( void)
|
||||
return false ;
|
||||
|
||||
// il centro va spostato di DeltaN
|
||||
if ( m_dDeltaN > EPS_ZERO)
|
||||
if ( fabs( m_dDeltaN) > EPS_ZERO)
|
||||
m_PtCen += m_dDeltaN * m_VtN ;
|
||||
// il versore normale rimane inalterato
|
||||
// il versore iniziale diventa quello finale
|
||||
@@ -809,6 +1018,113 @@ CurveArc::ToLoc( const Frame3d& frRef)
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::InvertN( void)
|
||||
{
|
||||
// la curva deve essere validata
|
||||
if ( m_nStatus != OK)
|
||||
return false ;
|
||||
|
||||
// si inverte il verso della normale senza modificare la geometria dell'arco
|
||||
m_VtN *= - 1 ;
|
||||
m_dAngCenDeg *= - 1 ;
|
||||
m_dDeltaN *= - 1 ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::ChangeRadius( double dNewRadius)
|
||||
{
|
||||
// la curva deve essere validata
|
||||
if ( m_nStatus != OK)
|
||||
return false ;
|
||||
|
||||
// cambio il raggio
|
||||
m_dRad = dNewRadius ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
// eseguo validazione
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::ChangeDeltaN( double dNewDeltaN)
|
||||
{
|
||||
// la curva deve essere validata
|
||||
if ( m_nStatus != OK)
|
||||
return false ;
|
||||
|
||||
// cambio il parametro
|
||||
m_dDeltaN = dNewDeltaN ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
// eseguo validazione
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::ToAdditional( void)
|
||||
{
|
||||
// la curva deve essere validata
|
||||
if ( m_nStatus != OK)
|
||||
return false ;
|
||||
// l'angolo al centro deve essere minore di un giro
|
||||
if ( fabs( m_dAngCenDeg) > ( ANG_FULL - EPS_ANG_SMALL))
|
||||
return false ;
|
||||
|
||||
// basta prendere l'angolo al centro che completa il giro
|
||||
m_dAngCenDeg = - _copysign( 360, m_dAngCenDeg) + m_dAngCenDeg ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveArc::Flip( void)
|
||||
{
|
||||
// la curva deve essere validata
|
||||
if ( m_nStatus != OK)
|
||||
return false ;
|
||||
// l'angolo al centro deve essere minore di un giro
|
||||
if ( fabs( m_dAngCenDeg) > ( ANG_FULL - EPS_ANG_SMALL))
|
||||
return false ;
|
||||
|
||||
// si calcola l'arco simmetrico rispetto alla linea che unisce gli estremi
|
||||
Point3d ptStart, ptEnd ;
|
||||
if ( ! GetStartPoint( ptStart) || ! GetEndPoint( ptEnd))
|
||||
return false ;
|
||||
// il punto finale mi interessa nel piano dell'arco
|
||||
if ( fabs( m_dDeltaN) > EPS_ZERO)
|
||||
ptEnd -= m_dDeltaN * m_VtN ;
|
||||
m_PtCen = ptStart + ( ptEnd - m_PtCen) ;
|
||||
m_VtS = ptStart - m_PtCen ;
|
||||
m_VtS.Normalize() ;
|
||||
m_dAngCenDeg = - m_dAngCenDeg ;
|
||||
|
||||
// imposto ricalcolo della grafica
|
||||
m_OGrMgr.Reset() ;
|
||||
|
||||
m_nStatus = TO_VERIFY ;
|
||||
return Validate() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
// Oggetto locale per approssimazione di archi
|
||||
// Approx interna è quella cordale standard.
|
||||
|
||||
+13
-5
@@ -83,15 +83,18 @@ class CurveArc : public ICurveArc, public IGeoObjRW
|
||||
virtual bool Copy( const IGeoObj* pGObjSrc) ;
|
||||
virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad,
|
||||
const Vector3d& vtS, double dAngCenDeg, double dDeltaN) ;
|
||||
virtual bool Set( const Point3d& ptIni, const Point3d& ptFin, const Vector3d& vtN, double dBulge) ;
|
||||
virtual bool Set( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ) ;
|
||||
virtual bool Set( const Point3d& ptCen, const Vector3d& vtN, double dRad) ;
|
||||
virtual bool Set( const Point3d& ptCen, double dRad) ;
|
||||
virtual bool SetXY( const Point3d& ptCen, double dRad, double dAngIniDeg, double dAngCenDeg, double dDeltaZ) ;
|
||||
virtual bool SetXY( const Point3d& ptCen, double dRad) ;
|
||||
virtual bool Set3P( const Point3d& ptStart, const Point3d& ptOther, const Point3d& ptEnd, bool bCirc = false) ;
|
||||
virtual bool Set2PNB( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtN, double dBulge) ;
|
||||
virtual bool Set2PD( const Point3d& ptStart, const Point3d& ptEnd, double dDirStartDeg) ;
|
||||
virtual bool Set2PRS( const Point3d& ptStart, const Point3d& ptEnd, double dRad, bool bCCW = true) ;
|
||||
virtual bool SetC2P( const Point3d& ptCen, const Point3d& ptStart, const Point3d& ptNearEnd) ;
|
||||
virtual bool IsFlat( void) const
|
||||
{ return ( fabs( m_dDeltaN) < EPS_SMALL) ; }
|
||||
virtual bool IsACircle( void) const
|
||||
{ return ( fabs( fabs( m_dAngCenDeg) - 360) < EPS_ANG_SMALL &&
|
||||
IsFlat() && IsClosed()) ; }
|
||||
{ return ( IsFlat() && IsClosed()) ; }
|
||||
virtual bool IsInPlaneXY( void) const
|
||||
{ return ( m_VtN.IsZplus()) ; }
|
||||
virtual const Point3d& GetCenter( void) const
|
||||
@@ -106,6 +109,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
|
||||
{ return m_dAngCenDeg ; }
|
||||
virtual double GetDeltaN( void) const
|
||||
{ return m_dDeltaN ; }
|
||||
virtual bool InvertN( void) ;
|
||||
virtual bool ChangeRadius( double dNewRadius) ;
|
||||
virtual bool ChangeDeltaN( double dNewDeltaN) ;
|
||||
virtual bool ToAdditional( void) ;
|
||||
virtual bool Flip( void) ;
|
||||
|
||||
public : // IGeoObjRW
|
||||
virtual int GetNgeId( void) const ;
|
||||
|
||||
+1
-1
@@ -304,7 +304,7 @@ CurveComposite::FromPointBulgeVector( const UPNTVECTOR& vUPnt, const Vector3d& v
|
||||
if ( ! ::IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( vUPnt[i-1].second, vUPnt[i].second, vtN, vUPnt[i-1].first))
|
||||
if ( ! pCrvArc->Set2PNB( vUPnt[i-1].second, vUPnt[i].second, vtN, vUPnt[i-1].first))
|
||||
return false ;
|
||||
// inserisco l'arco nella curva composta
|
||||
if ( ! AddSimpleCurve( Release( pCrvArc)))
|
||||
|
||||
+2
-2
@@ -53,7 +53,7 @@ CurveLine::Set( const Point3d& ptStart, const Point3d& ptEnd)
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveLine::Set( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
|
||||
CurveLine::SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
|
||||
{
|
||||
// assegno i dati
|
||||
m_PtStart = ptStart ;
|
||||
@@ -72,7 +72,7 @@ CurveLine::Set( const Point3d& ptStart, const Vector3d& vtDir, double dLen)
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
CurveLine::Set( const Point3d& ptStart, double dDirAngDeg, double dLen)
|
||||
CurveLine::SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen)
|
||||
{
|
||||
// assegno i dati
|
||||
m_PtStart = ptStart ;
|
||||
|
||||
+2
-2
@@ -82,8 +82,8 @@ class CurveLine : public ICurveLine, public IGeoObjRW
|
||||
public : // ICurveLine
|
||||
virtual bool Copy( const IGeoObj* pGObjSrc) ;
|
||||
virtual bool Set( const Point3d& ptStart, const Point3d& ptEnd) ;
|
||||
virtual bool Set( const Point3d& ptStart, const Vector3d& vtDir, double dLen) ;
|
||||
virtual bool Set( const Point3d& ptStart, double dDirAngDeg, double dLen) ;
|
||||
virtual bool SetPVL( const Point3d& ptStart, const Vector3d& vtDir, double dLen) ;
|
||||
virtual bool SetPDL( const Point3d& ptStart, double dDirAngDeg, double dLen) ;
|
||||
virtual const Point3d& GetStart( void) const
|
||||
{ return m_PtStart ; }
|
||||
virtual const Point3d& GetEnd( void) const
|
||||
|
||||
Binary file not shown.
+612
-240
@@ -419,269 +419,617 @@ GdbExecutor::ExecuteFrame( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveLine( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// creazione linea da : ptStart, ptEnd
|
||||
if ( sCmd2 == "" || sCmd2 == "MAKE")
|
||||
return CurveLineMake( vsParams) ;
|
||||
// creazione linea da : ptStart, vtDir, dLen
|
||||
else if ( sCmd2 == "VL" || sCmd2 == "VersorLength")
|
||||
return CurveLineVersorLength( vsParams) ;
|
||||
// creazione linea da : ptStart, dDirAngDeg, dLen
|
||||
else if ( sCmd2 == "DL" || sCmd2 == "DirLength")
|
||||
return CurveLineDirLength( vsParams) ;
|
||||
// creazione linea di minima distanza tra punto e curva
|
||||
else if ( sCmd2 == "MPC" || sCmd2 == "MINPOINTCURVE")
|
||||
return CurveLineMinPointCurve( vsParams) ;
|
||||
// altrimenti errore
|
||||
else
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveLineMake( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 4 parametri : Id, IdParent, ptStart, ptEnd
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// recupero punto iniziale
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
|
||||
return false ;
|
||||
// recupero punto finale
|
||||
Point3d ptEnd ;
|
||||
if ( ! GetPointParam( vsParams[3], frRef, ptEnd))
|
||||
return false ;
|
||||
// creo la linea
|
||||
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
|
||||
if ( ! IsValid( pCrvLine))
|
||||
return false ;
|
||||
|
||||
// creazione linea da : ptStart, ptEnd
|
||||
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
||||
// 4 parametri : Id, IdParent, ptStart, ptEnd
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// recupero punto iniziale
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
|
||||
return false ;
|
||||
// recupero punto finale
|
||||
Point3d ptEnd ;
|
||||
if ( ! GetPointParam( vsParams[3], frRef, ptEnd))
|
||||
return false ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->Set( ptStart, ptEnd))
|
||||
return false ;
|
||||
}
|
||||
// creazione linea da : ptStart, vtDir, dLen
|
||||
else if ( sCmd2 == "VL" || sCmd2 == "VersorLength") {
|
||||
// 5 parametri : Id, IdParent, ptStart, vtDir, dLen
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// recupero punto iniziale
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
|
||||
return false ;
|
||||
// recupero vettore direzione
|
||||
Vector3d vtDir ;
|
||||
if ( ! GetVectorParam( vsParams[3], frRef, vtDir))
|
||||
return false ;
|
||||
// recupero lunghezza
|
||||
double dLen ;
|
||||
if ( ! GetLengthParam( vsParams[4], dLen))
|
||||
return false ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->Set( ptStart, vtDir, dLen))
|
||||
return false ;
|
||||
}
|
||||
// creazione linea da : ptStart, dDirAngDeg, dLen
|
||||
else if ( sCmd2 == "DL" || sCmd2 == "DirLength") {
|
||||
// 5 parametri : Id, IdParent, ptStart, dAngDeg, dLen
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// recupero punto iniziale
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
|
||||
return false ;
|
||||
// recupero direzione in gradi
|
||||
double dDirAngDeg ;
|
||||
if ( ! GetDirParam( vsParams[3], frRef, dDirAngDeg))
|
||||
return false ;
|
||||
// recupero lunghezza
|
||||
double dLen ;
|
||||
if ( ! GetLengthParam( vsParams[4], dLen))
|
||||
return false ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->Set( ptStart, dDirAngDeg, dLen))
|
||||
return false ;
|
||||
}
|
||||
// creazione linea di minima distanza tra punto e curva
|
||||
else if ( sCmd2 == "MPC" || sCmd2 == "MINPOINTCURVE") {
|
||||
// almeno 4 parametri
|
||||
if ( vsParams.size() < 4)
|
||||
return false ;
|
||||
// recupero il riferimento del gruppo destinazione
|
||||
Frame3d frPoint ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPoint))
|
||||
return false ;
|
||||
// recupero il punto
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frPoint, ptStart))
|
||||
return false ;
|
||||
// recupero l'identificativo della curva
|
||||
int nId ;
|
||||
if ( ( nId = GetIdParam( vsParams[3])) == CMD_ID_ERROR)
|
||||
return false ;
|
||||
// recupero il riferimento della curva
|
||||
Frame3d frCurve ;
|
||||
if ( ! m_pGDB->GetGlobFrame( nId, frCurve))
|
||||
return false ;
|
||||
// recupero la curva
|
||||
const ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( nId)) ;
|
||||
if ( pCurve == nullptr)
|
||||
return false ;
|
||||
// porto il punto nel riferimento della curva
|
||||
Point3d ptSloc = ptStart ;
|
||||
ptSloc.LocToLoc( frPoint, frCurve) ;
|
||||
// recupero eventuale parametro per discriminare tra più soluzioni
|
||||
double dNearParam ;
|
||||
if ( vsParams.size() < 5 || ! FromString( vsParams[4], dNearParam))
|
||||
dNearParam = 0 ;
|
||||
// calcolo il punto a minima distanza
|
||||
int nFlag ;
|
||||
Point3d ptEnd ;
|
||||
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
|
||||
if ( ! dstPtCurve.GetMinDistPoint( dNearParam, ptEnd, nFlag))
|
||||
return false ;
|
||||
// porto il punto finale nel riferimento di creazione
|
||||
ptEnd.LocToLoc( frCurve, frPoint) ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->Set( ptStart, ptEnd))
|
||||
return false ;
|
||||
}
|
||||
// altrimenti errore
|
||||
else
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->Set( ptStart, ptEnd))
|
||||
return false ;
|
||||
|
||||
// inserisco la linea nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
|
||||
}
|
||||
|
||||
return false ;
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveLineVersorLength( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 5 parametri : Id, IdParent, ptStart, vtDir, dLen
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// recupero punto iniziale
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
|
||||
return false ;
|
||||
// recupero vettore direzione
|
||||
Vector3d vtDir ;
|
||||
if ( ! GetVectorParam( vsParams[3], frRef, vtDir))
|
||||
return false ;
|
||||
// recupero lunghezza
|
||||
double dLen ;
|
||||
if ( ! GetLengthParam( vsParams[4], dLen))
|
||||
return false ;
|
||||
// creo la linea
|
||||
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
|
||||
if ( ! IsValid( pCrvLine))
|
||||
return false ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->SetPVL( ptStart, vtDir, dLen))
|
||||
return false ;
|
||||
// inserisco la linea nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveLineDirLength( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 5 parametri : Id, IdParent, ptStart, dAngDeg, dLen
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// recupero punto iniziale
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptStart))
|
||||
return false ;
|
||||
// recupero direzione in gradi
|
||||
double dDirAngDeg ;
|
||||
if ( ! GetDirParam( vsParams[3], frRef, dDirAngDeg))
|
||||
return false ;
|
||||
// recupero lunghezza
|
||||
double dLen ;
|
||||
if ( ! GetLengthParam( vsParams[4], dLen))
|
||||
return false ;
|
||||
// creo la linea
|
||||
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
|
||||
if ( ! IsValid( pCrvLine))
|
||||
return false ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->SetPDL( ptStart, dDirAngDeg, dLen))
|
||||
return false ;
|
||||
// inserisco la linea nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveLineMinPointCurve( const STRVECTOR& vsParams)
|
||||
{
|
||||
// almeno 4 parametri : Id, IdParent, ptP, IdCrv[, NearParam]
|
||||
if ( vsParams.size() < 4)
|
||||
return false ;
|
||||
// recupero il riferimento del gruppo destinazione
|
||||
Frame3d frPoint ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frPoint))
|
||||
return false ;
|
||||
// recupero il punto
|
||||
Point3d ptStart ;
|
||||
if ( ! GetPointParam( vsParams[2], frPoint, ptStart))
|
||||
return false ;
|
||||
// recupero l'identificativo della curva
|
||||
int nId ;
|
||||
if ( ( nId = GetIdParam( vsParams[3])) == CMD_ID_ERROR)
|
||||
return false ;
|
||||
// recupero il riferimento della curva
|
||||
Frame3d frCurve ;
|
||||
if ( ! m_pGDB->GetGlobFrame( nId, frCurve))
|
||||
return false ;
|
||||
// recupero la curva
|
||||
const ICurve* pCurve = GetCurve( m_pGDB->GetGeoObj( nId)) ;
|
||||
if ( pCurve == nullptr)
|
||||
return false ;
|
||||
// porto il punto nel riferimento della curva
|
||||
Point3d ptSloc = ptStart ;
|
||||
ptSloc.LocToLoc( frPoint, frCurve) ;
|
||||
// recupero eventuale parametro per discriminare tra più soluzioni
|
||||
double dNearParam ;
|
||||
if ( vsParams.size() < 5 || ! FromString( vsParams[4], dNearParam))
|
||||
dNearParam = 0 ;
|
||||
// calcolo il punto a minima distanza
|
||||
int nFlag ;
|
||||
Point3d ptEnd ;
|
||||
DistPointCurve dstPtCurve( ptSloc, *pCurve) ;
|
||||
if ( ! dstPtCurve.GetMinDistPoint( dNearParam, ptEnd, nFlag))
|
||||
return false ;
|
||||
// porto il punto finale nel riferimento di creazione
|
||||
ptEnd.LocToLoc( frCurve, frPoint) ;
|
||||
// creo la linea
|
||||
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
|
||||
if ( ! IsValid( pCrvLine))
|
||||
return false ;
|
||||
// setto la linea
|
||||
if ( ! pCrvLine->Set( ptStart, ptEnd))
|
||||
return false ;
|
||||
// inserisco la linea nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvLine)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveArc( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
{
|
||||
// creo arco generico
|
||||
if ( sCmd2 == "" || sCmd2 == "MAKE")
|
||||
return CurveArcMake( vsParams) ;
|
||||
// creo circonferenza
|
||||
else if ( sCmd2 == "C" || sCmd2 == "CIRCLE")
|
||||
return CurveArcCircle( vsParams) ;
|
||||
// creo arco nel piano XY
|
||||
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY")
|
||||
return CurveArcPlaneXY( vsParams) ;
|
||||
// creo circonferenza nel piano XY
|
||||
else if ( sCmd2 == "CXY" || sCmd2 == "CIRCLEXY")
|
||||
return CurveArcCircleXY( vsParams) ;
|
||||
// creo arco o circonferenza passante per 3 punti
|
||||
else if ( sCmd2 == "3P" || sCmd2 == "C3P")
|
||||
return CurveArc3P( vsParams, ( sCmd2 == "C3P")) ;
|
||||
// creo arco per 2 punti e direzione iniziale
|
||||
else if ( sCmd2 == "2PDI")
|
||||
return CurveArc2PDi( vsParams) ;
|
||||
// creo arco per 2 punti, raggio e senso di rotazione
|
||||
else if ( sCmd2 == "2PRS")
|
||||
return CurveArc2PRS( vsParams) ;
|
||||
// creo arco dato centro, per primo punto e vicino al secondo
|
||||
else if ( sCmd2 == "C2P")
|
||||
return CurveArcC2P( vsParams) ;
|
||||
// inversione della normale
|
||||
else if ( sCmd2 == "INVN" || sCmd2 == "INVERTNORMAL")
|
||||
return CurveArcInvertNormal( vsParams) ;
|
||||
// cambio del raggio
|
||||
else if ( sCmd2 == "CHR" || sCmd2 == "CHANGERADIUS")
|
||||
return CurveArcChangeRadius( vsParams) ;
|
||||
// cambio del deltaN
|
||||
else if ( sCmd2 == "CHDN" || sCmd2 == "CHANGEDELTAN")
|
||||
return CurveArcChangeDeltaN( vsParams) ;
|
||||
// trasformazione nell'arco complementare
|
||||
else if ( sCmd2 == "TA" || sCmd2 == "TOADDITIONAL")
|
||||
return CurveArcToAdditional( vsParams) ;
|
||||
// flip dell'arco
|
||||
else if ( sCmd2 == "F" || sCmd2 == "FLIP")
|
||||
return CurveArcFlip( vsParams) ;
|
||||
// altrimenti errore
|
||||
else
|
||||
return false ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcMake( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 8 parametri
|
||||
if ( vsParams.size() != 8)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// versore ortogonale al piano della circonferenza
|
||||
Vector3d vtN ;
|
||||
if ( ! GetVectorParam( vsParams[3], frRef, vtN))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! GetLengthParam( vsParams[4], dRad))
|
||||
return false ;
|
||||
// versore iniziale
|
||||
Vector3d vtS ;
|
||||
if ( ! GetVectorParam( vsParams[5], frRef, vtS))
|
||||
return false ;
|
||||
// angolo al centro
|
||||
double dAngCenDeg ;
|
||||
if ( ! FromString( vsParams[6], dAngCenDeg))
|
||||
return false ;
|
||||
// deltaZ
|
||||
double dDeltaZ ;
|
||||
if ( ! GetLengthParam( vsParams[7], dDeltaZ))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
|
||||
// arco generico
|
||||
if ( sCmd2 == "" || sCmd2 == "MAKE") {
|
||||
// 8 parametri
|
||||
if ( vsParams.size() != 8)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// versore ortogonale al piano della circonferenza
|
||||
Vector3d vtN ;
|
||||
if ( ! GetVectorParam( vsParams[3], frRef, vtN))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! FromString( vsParams[4], dRad))
|
||||
return false ;
|
||||
// versore iniziale
|
||||
Vector3d vtS ;
|
||||
if ( ! GetVectorParam( vsParams[5], frRef, vtS))
|
||||
return false ;
|
||||
// angolo al centro
|
||||
double dAngCenDeg ;
|
||||
if ( ! FromString( vsParams[6], dAngCenDeg))
|
||||
return false ;
|
||||
// deltaZ
|
||||
double dDeltaZ ;
|
||||
if ( ! FromString( vsParams[7], dDeltaZ))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
|
||||
return false ;
|
||||
}
|
||||
// arco nel piano XY
|
||||
else if ( sCmd2 == "XY" || sCmd2 == "PLANEXY") {
|
||||
// 7 parametri
|
||||
if ( vsParams.size() != 7)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! FromString( vsParams[3], dRad))
|
||||
return false ;
|
||||
// angolo iniziale
|
||||
double dAngIniDeg ;
|
||||
if ( ! FromString( vsParams[4], dAngIniDeg))
|
||||
return false ;
|
||||
// angolo al centro
|
||||
double dAngCenDeg ;
|
||||
if ( ! FromString( vsParams[5], dAngCenDeg))
|
||||
return false ;
|
||||
// deltaZ
|
||||
double dDeltaZ ;
|
||||
if ( ! FromString( vsParams[6], dDeltaZ))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
|
||||
return false ;
|
||||
}
|
||||
// circonferenza
|
||||
else if ( sCmd2 == "C" || sCmd2 == "CIRCLE") {
|
||||
// 5 parametri
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// versore ortogonale al piano della circonferenza
|
||||
Vector3d vtN ;
|
||||
if ( ! GetVectorParam( vsParams[3], frRef, vtN))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! FromString( vsParams[4], dRad))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, vtN, dRad))
|
||||
return false ;
|
||||
}
|
||||
// circonferenza nel piano XY
|
||||
else if ( sCmd2 == "CXY" || sCmd2 == "CIRCLEXY") {
|
||||
// 4 parametri
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! FromString( vsParams[3], dRad))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, dRad))
|
||||
return false ;
|
||||
}
|
||||
// altrimenti errore
|
||||
else
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, vtN, dRad, vtS, dAngCenDeg, dDeltaZ))
|
||||
return false ;
|
||||
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcPlaneXY( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 7 parametri
|
||||
if ( vsParams.size() != 7)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! GetLengthParam( vsParams[3], dRad))
|
||||
return false ;
|
||||
// angolo iniziale
|
||||
double dAngIniDeg ;
|
||||
if ( ! GetDirParam( vsParams[4], frRef, dAngIniDeg))
|
||||
return false ;
|
||||
// angolo al centro
|
||||
double dAngCenDeg ;
|
||||
if ( ! FromString( vsParams[5], dAngCenDeg))
|
||||
return false ;
|
||||
// deltaZ
|
||||
double dDeltaZ ;
|
||||
if ( ! GetLengthParam( vsParams[6], dDeltaZ))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->SetXY( ptCen, dRad, dAngIniDeg, dAngCenDeg, dDeltaZ))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcCircle( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 5 parametri
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// versore ortogonale al piano della circonferenza
|
||||
Vector3d vtN ;
|
||||
if ( ! GetVectorParam( vsParams[3], frRef, vtN))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! GetLengthParam( vsParams[4], dRad))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set( ptCen, vtN, dRad))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcCircleXY( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 4 parametri
|
||||
if ( vsParams.size() != 4)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! GetLengthParam( vsParams[3], dRad))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->SetXY( ptCen, dRad))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArc3P( const STRVECTOR& vsParams, bool bCirc)
|
||||
{
|
||||
// 5 parametri : Id, ParentId, ptP0, ptP1, ptP2
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// primo punto
|
||||
Point3d ptP0 ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptP0))
|
||||
return false ;
|
||||
// secondo punto
|
||||
Point3d ptP1 ;
|
||||
if ( ! GetPointParam( vsParams[3], frRef, ptP1))
|
||||
return false ;
|
||||
// terzo punto
|
||||
Point3d ptP2 ;
|
||||
if ( ! GetPointParam( vsParams[4], frRef, ptP2))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set3P( ptP0, ptP1, ptP2, bCirc))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArc2PDi( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 5 parametri : Id, ParentId, ptPi, ptPf, dDiri
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// punto iniziale
|
||||
Point3d ptPi ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptPi))
|
||||
return false ;
|
||||
// punto finale
|
||||
Point3d ptPf ;
|
||||
if ( ! GetPointParam( vsParams[3], frRef, ptPf))
|
||||
return false ;
|
||||
// direzione iniziale
|
||||
double dDirI ;
|
||||
if ( ! GetDirParam( vsParams[4], frRef, dDirI))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set2PD( ptPi, ptPf, dDirI))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArc2PRS( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 5 o 6 parametri : Id, ParentId, ptPi, ptPf, dRad[, CCW/CW]
|
||||
if ( vsParams.size() != 5 && vsParams.size() != 6)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// punto iniziale
|
||||
Point3d ptPi ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptPi))
|
||||
return false ;
|
||||
// punto finale
|
||||
Point3d ptPf ;
|
||||
if ( ! GetPointParam( vsParams[3], frRef, ptPf))
|
||||
return false ;
|
||||
// raggio
|
||||
double dRad ;
|
||||
if ( ! GetLengthParam( vsParams[4], dRad))
|
||||
return false ;
|
||||
// senso di rotazione
|
||||
bool bCCW = true ;
|
||||
if ( vsParams.size() >= 6 && vsParams[5] == "CW")
|
||||
bCCW = false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->Set2PRS( ptPi, ptPf, dRad, bCCW))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcC2P( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 5 parametri : Id, ParentId, ptCen, ptPi, ptNearPf
|
||||
if ( vsParams.size() != 5)
|
||||
return false ;
|
||||
// recupero il riferimento in cui è immerso
|
||||
Frame3d frRef ;
|
||||
if ( ! m_pGDB->GetGroupGlobFrame( GetIdParam( vsParams[1]), frRef))
|
||||
return false ;
|
||||
// centro
|
||||
Point3d ptCen ;
|
||||
if ( ! GetPointParam( vsParams[2], frRef, ptCen))
|
||||
return false ;
|
||||
// punto iniziale
|
||||
Point3d ptPi ;
|
||||
if ( ! GetPointParam( vsParams[3], frRef, ptPi))
|
||||
return false ;
|
||||
// punto vicino al finale (direzione da centro esatta)
|
||||
Point3d ptNearPf ;
|
||||
if ( ! GetPointParam( vsParams[4], frRef, ptNearPf))
|
||||
return false ;
|
||||
// creo l'arco
|
||||
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
|
||||
if ( ! IsValid( pCrvArc))
|
||||
return false ;
|
||||
// setto l'arco
|
||||
if ( ! pCrvArc->SetC2P( ptCen, ptPi, ptNearPf))
|
||||
return false ;
|
||||
// inserisco l'arco nel DB
|
||||
return AddGeoObj( vsParams[0], vsParams[1], Release( pCrvArc)) ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcInvertNormal( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 1 parametro : Id
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// recupero l'arco
|
||||
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
|
||||
if ( pCrvArc == nullptr)
|
||||
return false ;
|
||||
// eseguo l'operazione
|
||||
return pCrvArc->InvertN() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcChangeRadius( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 2 parametrio : Id, dNewRad
|
||||
if ( vsParams.size() != 2)
|
||||
return false ;
|
||||
// recupero lista Id
|
||||
INTVECTOR vnNames ;
|
||||
if ( ! GetNamesParam( vsParams[0], vnNames))
|
||||
return false ;
|
||||
// leggo il nuovo raggio
|
||||
double dNewRad ;
|
||||
if ( ! GetLengthParam( vsParams[1], dNewRad))
|
||||
return false ;
|
||||
// esecuzione
|
||||
INTVECTOR::iterator Iter ;
|
||||
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
||||
// recupero l'arco
|
||||
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ;
|
||||
if ( pCrvArc == nullptr)
|
||||
return false ;
|
||||
// eseguo l'operazione
|
||||
if ( ! pCrvArc->ChangeRadius( dNewRad))
|
||||
return false ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcChangeDeltaN( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 2 parametro : Id, dNewDeltaN
|
||||
if ( vsParams.size() != 2)
|
||||
return false ;
|
||||
// recupero lista Id
|
||||
INTVECTOR vnNames ;
|
||||
if ( ! GetNamesParam( vsParams[0], vnNames))
|
||||
return false ;
|
||||
// leggo il nuovo delta
|
||||
double dNewDeltaN ;
|
||||
if ( ! GetLengthParam( vsParams[1], dNewDeltaN))
|
||||
return false ;
|
||||
// esecuzione
|
||||
INTVECTOR::iterator Iter ;
|
||||
for ( Iter = vnNames.begin() ; Iter != vnNames.end() ; ++Iter) {
|
||||
// recupero l'arco
|
||||
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( *Iter)) ;
|
||||
if ( pCrvArc == nullptr)
|
||||
return false ;
|
||||
// eseguo l'operazione
|
||||
if ( ! pCrvArc->ChangeDeltaN( dNewDeltaN))
|
||||
return false ;
|
||||
}
|
||||
return true ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcToAdditional( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 1 parametro : Id
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// recupero l'arco
|
||||
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
|
||||
if ( pCrvArc == nullptr)
|
||||
return false ;
|
||||
// eseguo l'operazione
|
||||
return pCrvArc->ToAdditional() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::CurveArcFlip( const STRVECTOR& vsParams)
|
||||
{
|
||||
// 1 parametro : Id
|
||||
if ( vsParams.size() != 1)
|
||||
return false ;
|
||||
// recupero l'arco
|
||||
ICurveArc* pCrvArc = GetCurveArc( m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) ;
|
||||
if ( pCrvArc == nullptr)
|
||||
return false ;
|
||||
// eseguo l'operazione
|
||||
return pCrvArc->Flip() ;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
bool
|
||||
GdbExecutor::ExecuteCurveBez( const string& sCmd2, const STRVECTOR& vsParams)
|
||||
@@ -1704,6 +2052,30 @@ GdbExecutor::GetLengthParam( const string& sParam, double& dLen)
|
||||
}
|
||||
return false ;
|
||||
}
|
||||
// se raggio notevole
|
||||
else if ( sParam[0] == 'R') {
|
||||
// recupero i parametri associati
|
||||
STRVECTOR vsParams ;
|
||||
Tokenize( sParam.substr( 1), ",", vsParams) ;
|
||||
STRVECTOR::iterator Iter ;
|
||||
for ( Iter = vsParams.begin() ; Iter != vsParams.end() ; ++Iter)
|
||||
Trim( (*Iter), " \t\r\n()") ;
|
||||
// ci deve essere almeno un parametro
|
||||
if ( vsParams.size() < 1)
|
||||
return false ;
|
||||
// recupero l'entità indicata dal primo parametro
|
||||
const IGeoObj* pGObj ;
|
||||
if ( ( pGObj = m_pGDB->GetGeoObj( GetIdParam( vsParams[0]))) == nullptr)
|
||||
return false ;
|
||||
// se arco
|
||||
if ( pGObj->GetType() == CRV_ARC) {
|
||||
// recupero l'arco
|
||||
const ICurveArc* pCrvArc = GetCurveArc( pGObj) ;
|
||||
dLen = pCrvArc->GetRadius() ;
|
||||
return true ;
|
||||
}
|
||||
return false ;
|
||||
}
|
||||
// altrimenti valore numerico
|
||||
else {
|
||||
return FromString( sParam, dLen) ;
|
||||
|
||||
@@ -53,7 +53,24 @@ class GdbExecutor : public IGdbExecutor
|
||||
bool ExecuteVector( const std::string& sCmd2, const STRVECTOR& vsParams) ;
|
||||
bool ExecuteFrame( const std::string& sCmd2, const STRVECTOR& vsParams) ;
|
||||
bool ExecuteCurveLine( const std::string& sCmd2, const STRVECTOR& vsParams) ;
|
||||
bool CurveLineMake( const STRVECTOR& vsParams) ;
|
||||
bool CurveLineVersorLength( const STRVECTOR& vsParams) ;
|
||||
bool CurveLineDirLength( const STRVECTOR& vsParams) ;
|
||||
bool CurveLineMinPointCurve( const STRVECTOR& vsParams) ;
|
||||
bool ExecuteCurveArc( const std::string& sCmd2, const STRVECTOR& vsParams) ;
|
||||
bool CurveArcMake( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcPlaneXY( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcCircle( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcCircleXY( const STRVECTOR& vsParams) ;
|
||||
bool CurveArc3P( const STRVECTOR& vsParams, bool bCirc) ;
|
||||
bool CurveArc2PDi( const STRVECTOR& vsParams) ;
|
||||
bool CurveArc2PRS( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcC2P( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcInvertNormal( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcChangeRadius( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcChangeDeltaN( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcToAdditional( const STRVECTOR& vsParams) ;
|
||||
bool CurveArcFlip( const STRVECTOR& vsParams) ;
|
||||
bool ExecuteCurveBez( const std::string& sCmd2, const STRVECTOR& vsParams) ;
|
||||
bool ExecuteCurveCompo( const std::string& sCmd2, const STRVECTOR& vsParams) ;
|
||||
bool CurveCompoMake( const STRVECTOR& vsParams) ;
|
||||
|
||||
Reference in New Issue
Block a user