EgtGeomKernel :

- in Tsc sostituita OutScl con OutTsc
- in Tsc aggiunti nomi predefiniti per vettori, punti e riferimenti.

OutTsc.cpp

@@ -0,0 +1,633 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2013-2014
+//----------------------------------------------------------------------------
+// File : OutTsc.cpp            Data : 23.03.14          Versione : 1.5c9
+// Contenuto : Implementazione della classe output Tsc.
+//
+//
+//
+// Modifiche : 23.03.14 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "OutTsc.h"
+#include "/EgtDev/Include/EgkGeoVector3d.h"
+#include "/EgtDev/Include/EgkGeoPoint3d.h"
+#include "/EgtDev/Include/EgkGeoFrame3d.h"
+#include "/EgtDev/Include/EgkCurveLine.h"
+#include "/EgtDev/Include/EgkCurveArc.h"
+#include "/EgtDev/Include/EgkCurveBezier.h"
+#include "/EgtDev/Include/EgkCurveComposite.h"
+#include "/EgtDev/Include/EGkStringUtils3d.h"
+#include "/EgtDev/Include/EGnStringConverter.h"
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+OutTsc::OutTsc( void)
+{
+   m_nId = 0 ;
+   m_nGroup.push( 0) ;
+   m_bOutCol = false ;
+}
+
+//----------------------------------------------------------------------------
+OutTsc::~OutTsc( void)
+{
+   Close() ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Open( const string& sOutTsc)
+{
+  // apro il file
+   m_ofFile.open( stringtoW( sOutTsc)) ;
+   if ( ! m_ofFile.good())
+      return false ;
+  // scrivo linee iniziali
+   Start() ;
+   New() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Close( void)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+  // scrivo linee finali
+   End() ;
+  // chiudo il file
+   m_ofFile.close() ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Start( void)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+  // inizializzazioni
+   m_nId = 0 ;
+   m_nGroup.top() = 0 ;
+   m_bOutCol = false ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::End( void)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::New( void)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+  // emetto stringa
+   m_ofFile << "NEW" << endl ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Remark( const string& sRemark)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+  // emetto stringa
+   m_ofFile << "// " << sRemark << endl ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::SetMaterial( double dRed, double dGreen, double dBlue)
+{
+   m_bOutCol = true ;
+   m_cCol.Set( dRed, dGreen, dBlue) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PutMaterial( int nObjId, bool bGroup)
+{
+  // se necessario emetto il materiale
+   if ( m_bOutCol  ||  bGroup) {
+      m_ofFile << "MAT( " << ToString( nObjId) << ", (" << ToString( m_cCol) << "))" << endl ;
+      if ( bGroup)
+         m_bOutCol = false ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PushGroup( void)
+{
+   int nVal = ( m_nGroup.empty() ? 0 : m_nGroup.top()) ;
+   m_nGroup.push( nVal) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PopGroup( void)
+{
+   if ( m_nGroup.size() <= 1)
+      return false ;
+   m_nGroup.pop() ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::NewGroup( int nLev)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // calcolo gruppo di appartenenza
+   string sParent = (( nLev == 0) ? "$ROOT" : ToString( m_nGroup.top())) ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // assegno indice gruppo corrente
+   m_nGroup.top() = m_nId ;
+
+  // creo il gruppo del pezzo
+   m_ofFile << "GR.XY( " << ToString( m_nGroup.top()) << ", " << sParent << ", (0,0,0))" << endl ;
+
+  // emetto il materiale
+   PutMaterial( m_nGroup.top(), true) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::NewGroupRef( const Frame3d& frFrame, int nLev)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // calcolo gruppo di appartenenza
+   string sParent = (( nLev == 0) ? "$ROOT" : ToString( m_nGroup.top())) ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // assegno indice layer corrente
+   m_nGroup.top() = m_nId ;
+
+  // creo il gruppo del layer
+   m_ofFile << "GR( " << ToString( m_nGroup.top()) << ", " << sParent << ", " ;
+   m_ofFile << "(" << ToString( frFrame.Orig()) << "), " ;
+   m_ofFile << "(" << ToString( frFrame.VersX()) << "), " ;
+   m_ofFile << "(" << ToString( frFrame.VersY()) << "), " ;
+   m_ofFile << "(" << ToString( frFrame.VersZ()) << "))" << endl ;
+
+  // emetto il materiale
+   PutMaterial( m_nGroup.top(), true) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PutCurrRef( void)
+{
+   return Frame( Frame3d()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Vector( const Vector3d& vtV)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // verifico non sia praticamente nullo
+   if ( vtV.IsSmall())
+      return true ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // emetto vettore
+   m_ofFile << "V( " << ToString( m_nId) << ", " << ToString( m_nGroup.top()) << ", " ;
+   m_ofFile << ToString( vtV) << ")" << endl ;
+
+  // se necessario emetto il materiale
+   PutMaterial( m_nId) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Point( const Point3d& ptP)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // emetto punto
+   m_ofFile << "P( " << ToString( m_nId) << ", " << ToString( m_nGroup.top()) << ", " ;
+   m_ofFile << ToString( ptP) << ")" << endl ;
+
+  // se necessario emetto il materiale
+   PutMaterial( m_nId) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Frame( const Frame3d& frF)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // emetto riferimento
+   m_ofFile << "FR( " << ToString( m_nId) << ", " << ToString( m_nGroup.top()) << ", " ;
+   m_ofFile << "(" << ToString( frF.Orig()) << "), " ;
+   m_ofFile << "(" << ToString( frF.VersX()) << "), " ;
+   m_ofFile << "(" << ToString( frF.VersY()) << "), " ;
+   m_ofFile << "(" << ToString( frF.VersZ()) << "))" << endl ;
+
+  // non usa materiale
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::Line2P( const Point3d& ptP1, const Point3d& ptP2)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // verifico non sia praticamente nulla
+   if ( AreSamePointNear( ptP1, ptP2))
+      return true ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // emetto linea
+   m_ofFile << "CL( " << ToString( m_nId) << ", " << ToString( m_nGroup.top()) << ", " ;
+   m_ofFile << "(" << ToString( ptP1) << "), (" << ToString( ptP2) << "))" << endl ;
+
+  // se necessario emetto il materiale
+   PutMaterial( m_nId) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::ArcCPA( const Point3d& ptCen, const Point3d& ptMed, double dAngCenDeg)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // calcolo il raggio e l'angolo iniziale
+   double dRad ;
+   double dAngIniDeg ;
+   Vector3d( ptMed - ptCen).ToSpherical( &dRad, nullptr, &dAngIniDeg) ;
+   dAngIniDeg -= 0.5 * dAngCenDeg ;
+
+  // verifico non sia praticamente nulla
+   if ( fabs( dRad) < EPS_SMALL  ||  fabs( dAngCenDeg) < EPS_ANG_SMALL)
+      return true ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // emetto arco
+   m_ofFile << "CA.XY( " << ToString( m_nId) << ", " << ToString( m_nGroup.top()) << ", " ;
+   m_ofFile << "(" << ToString( ptCen) << "), " << ToString( dRad) << ", " ;
+   m_ofFile << ToString( dAngIniDeg) << ", " << ToString( dAngCenDeg) << ", 0)" << endl ;
+
+  // se necessario emetto il materiale
+   PutMaterial( m_nId) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::CircleCR( const Point3d& ptCen, double dRad)
+{
+  // verifico sia aperto
+   if ( ! m_ofFile.is_open())
+      return false ;
+
+  // incremento indice corrente
+   ++ m_nId ;
+
+  // emetto circonferenza
+   m_ofFile << "CA.CXY( " << ToString( m_nId) << ", " << ToString( m_nGroup.top()) << ", " ;
+   m_ofFile << "(" << ToString( ptCen) << "), " << ToString( dRad) << ")" << endl ;
+
+  // se necessario emetto il materiale
+   PutMaterial( m_nId) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::ArcCurvOrTgOrNone( const CrvPointDiffGeom& oDiffG)
+{
+  // curvatura
+   if ( oDiffG.nStatus == CrvPointDiffGeom::NCRV  &&  fabs( oDiffG.dCurv) > EPS_ZERO) {
+     // tratto di arco
+      Point3d ptCen = oDiffG.ptP + oDiffG.vtN / oDiffG.dCurv ;
+      bool bCCW = ( oDiffG.vtT ^ oDiffG.vtN).z > 0 ;
+      double  dAngCenDeg = ( bCCW ? 1 : -1) * 4 * oDiffG.dCurv * RADTODEG ;
+      ArcCPA( ptCen, oDiffG.ptP, dAngCenDeg) ;
+     // raggio
+      Line2P( oDiffG.ptP, ptCen) ;
+   }
+  // altrimenti, tangente
+   else if ( oDiffG.nStatus == CrvPointDiffGeom::TANG  &&  ! oDiffG.vtT.IsSmall())
+      Line2P( oDiffG.ptP - oDiffG.vtT, oDiffG.ptP + oDiffG.vtT) ;
+  // altrimenti cerchietto
+   else
+      CircleCR( oDiffG.ptP, 1) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::NormalOrNone( const CrvPointDiffGeom& oDiffG)
+{
+   const double NORM_LEN = 10 ;
+
+
+  // normale
+   if ( oDiffG.nStatus == CrvPointDiffGeom::NCRV  &&  fabs( oDiffG.dCurv) > EPS_ZERO) {
+      double dLen = __min( NORM_LEN, 1 / oDiffG.dCurv) ;
+      Line2P( oDiffG.ptP - NORM_LEN * oDiffG.vtN, oDiffG.ptP + dLen * oDiffG.vtN) ;
+   }
+  // segmento perpendicolare alla tangente
+   else if ( oDiffG.nStatus == CrvPointDiffGeom::TANG  &&  ! oDiffG.vtT.IsSmall()) {
+      Vector3d vtN = oDiffG.vtT ^ Z_AX ;
+      if ( ! vtN.Normalize()) {
+         vtN = oDiffG.vtT ^ Y_AX ;
+         vtN.Normalize() ;
+      }
+      Line2P( oDiffG.ptP - NORM_LEN * vtN, oDiffG.ptP + NORM_LEN * vtN) ;
+   }
+  // altrimenti cerchietto
+   else
+      CircleCR( oDiffG.ptP, 1) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PutGeoObj( const IGeoObj* pGeoObj, int nFlag)
+{
+  // GeoVector3d
+   if ( pGeoObj->GetType() == GEO_VECT3D) {
+      const IGeoVector3d* pGVector ;
+     // recupero e controllo il vettore
+      if ( ( pGVector = GetGeoVector3d( pGeoObj)) == nullptr)
+         return false ;
+     // eseguo output
+      return Vector( pGVector->GetVector()) ;
+   }
+  // GeoPoint3d
+   else if ( pGeoObj->GetType() == GEO_PNT3D) {
+      const IGeoPoint3d* pGPoint ;
+     // recupero e controllo il punto
+      if ( ( pGPoint = GetGeoPoint3d( pGeoObj)) == nullptr)
+         return false ;
+     // eseguo output
+      return Point( pGPoint->GetPoint()) ;
+   }
+  // GeoFrame3d
+   else if ( pGeoObj->GetType() == GEO_FRAME3D) {
+      const IGeoFrame3d* pGFrame ;
+     // recupero e controllo il punto
+      if ( ( pGFrame = GetGeoFrame3d( pGeoObj)) == nullptr)
+         return false ;
+     // eseguo output
+      return Frame( pGFrame->GetFrame()) ;
+   }
+  // Curve (Line, Arc, Bezier, Composite)
+   else if (( pGeoObj->GetType() & GEO_CURVE) != 0) {
+      const ICurve* pCurve ;
+     // recupero e controllo la curva
+      if ( ( pCurve = GetCurve( pGeoObj)) == nullptr)
+         return false ;
+     // eseguo output
+      return PutCurve( pCurve, nFlag) ;
+   }
+   else   
+      return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PutCurve( const ICurve* pCurve, int nFlag)
+{
+  // ciclo per disegnare i segmenti
+   Remark( "Curve") ;
+   Point3d  ptIni ;
+   Point3d  ptFin ;
+   PolyLine PL ;
+   pCurve->ApproxWithLines( 0.1, 5, PL) ;
+   for ( bool bFound = PL.GetFirstLine( ptIni, ptFin) ; bFound ; bFound = PL.GetNextLine( ptIni, ptFin))
+      Line2P( ptIni, ptFin) ;
+
+  // se richieste tangenti e curvature
+   if ( ( nFlag & 1) != 0) {
+     // ciclo per disegnare le derivate e le curvature
+      Remark( "Curve:Tangents+Der2") ;
+      double dU ;
+      for ( bool bFound = PL.GetFirstU( dU) ; bFound ; bFound = PL.GetNextU( dU)) {
+        // ricavo il punto, la tangente, la normale e la curvatura
+         CrvPointDiffGeom oDiffG ;
+         pCurve->GetPointDiffGeom( dU, ICurve::FROM_MINUS, oDiffG) ;
+        // curvatura o tangente o niente
+         ArcCurvOrTgOrNone( oDiffG) ;
+        // se punto con possibili discontinuità
+         if ( oDiffG.nFlag == CrvPointDiffGeom::TO_VERIFY) {
+           // ricavo il punto, la tangente, la normale e la curvatura dall'intorno superiore
+            CrvPointDiffGeom oDiffGs ;
+            pCurve->GetPointDiffGeom( dU, ICurve::FROM_PLUS, oDiffGs) ;
+           // se ci sono delle discontinuità
+            if ( ThereIsDiscontinuity( oDiffG, oDiffGs))
+              // emetto curvatura o tangente o niente
+               ArcCurvOrTgOrNone( oDiffGs) ;
+         }
+      }
+   }
+
+  // se richieste normali
+   if ( ( nFlag & 2) != 0) {
+     // ciclo per disegnare le derivate e le curvature
+      Remark( "Curve:Normals") ;
+      double dU ;
+      for ( bool bFound = PL.GetFirstU( dU) ; bFound ; bFound = PL.GetNextU( dU)) {
+        // ricavo il punto, la tangente, la normale e la curvatura
+         CrvPointDiffGeom oDiffG ;
+         pCurve->GetPointDiffGeom( dU, ICurve::FROM_MINUS, oDiffG) ;
+        // curvatura o tangente o niente
+         NormalOrNone( oDiffG) ;
+        // se punto con possibili discontinuità
+         if ( oDiffG.nFlag == CrvPointDiffGeom::TO_VERIFY) {
+           // ricavo il punto, la tangente, la normale e la curvatura dall'intorno superiore
+            CrvPointDiffGeom oDiffGs ;
+            pCurve->GetPointDiffGeom( dU, ICurve::FROM_PLUS, oDiffGs) ;
+           // se ci sono delle discontinuità
+            if ( ThereIsDiscontinuity( oDiffG, oDiffGs))
+              // normale o niente
+               NormalOrNone( oDiffGs) ;
+         }
+      }
+   }
+
+  // se curva di Bezier e richiesto anche il poligono di controllo
+   if ( pCurve->GetType() == CRV_BEZ  &&  ( nFlag & 4) != 0)
+      PutPolygBez( *(GetCurveBezier( pCurve))) ;
+
+  // se richiesto il box
+   if ( ( nFlag & 8) != 0) {
+      BBox3d b3B ;
+      if ( pCurve->GetLocalBBox( b3B))
+         PutBBox( b3B) ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PutPolygBez( const ICurveBezier& CrvBez)
+{
+   int     i ;
+   Point3d ptIni ;
+   Point3d ptFin ;
+
+
+  // ciclo per disegnare il poligono di controllo
+   Remark( "BezierPolygon") ;
+   ptIni = CrvBez.GetControlPoint( 0) ;
+   for ( i = 1 ; i <= CrvBez.GetDegree() ; ++ i) {
+      ptFin = CrvBez.GetControlPoint( i) ;
+     // disegno
+      Line2P( ptIni, ptFin) ;
+     // nuovo iniziale prende i valori del finale
+      ptIni = ptFin ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+OutTsc::PutBBox( const BBox3d& b3B)
+{
+   Point3d ptMin ;
+   Point3d ptMax ;
+
+
+   if ( b3B.GetMinMax( ptMin, ptMax)) {
+      Remark( "BoundingBox") ;
+     // se ridotto a un punto
+      if ( AreSamePointNear( ptMin, ptMax))
+         Point( ptMin) ;
+     // se ridotto ad una linea
+      else if ( (( ptMax.x - ptMin.x) < EPS_SMALL  &&  ( ptMax.y - ptMin.y) < EPS_SMALL)  ||
+                (( ptMax.y - ptMin.y) < EPS_SMALL  &&  ( ptMax.z - ptMin.z) < EPS_SMALL)  ||
+                (( ptMax.z - ptMin.z) < EPS_SMALL  &&  ( ptMax.x - ptMin.x) < EPS_SMALL))
+         Line2P( ptMin, ptMax) ;
+     // se ridotto ad un rettangolo nel piano XY
+      else if ( ( ptMax.z - ptMin.z) < EPS_SMALL) {
+        // giro a Zmin
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMin.z), Point3d( ptMax.x, ptMin.y, ptMin.z)) ;
+         Line2P( Point3d( ptMax.x, ptMin.y, ptMin.z), Point3d( ptMax.x, ptMax.y, ptMin.z)) ;
+         Line2P( Point3d( ptMax.x, ptMax.y, ptMin.z), Point3d( ptMin.x, ptMax.y, ptMin.z)) ;
+         Line2P( Point3d( ptMin.x, ptMax.y, ptMin.z), Point3d( ptMin.x, ptMin.y, ptMin.z)) ;
+      }
+     // se ridotto ad un rettangolo nel piano YZ
+      else if ( ( ptMax.x - ptMin.x) < EPS_SMALL) {
+        // giro a Xmin
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMin.z), Point3d( ptMin.x, ptMax.y, ptMin.z)) ;
+         Line2P( Point3d( ptMin.x, ptMax.y, ptMin.z), Point3d( ptMin.x, ptMax.y, ptMax.z)) ;
+         Line2P( Point3d( ptMin.x, ptMax.y, ptMax.z), Point3d( ptMin.x, ptMin.y, ptMax.z)) ;
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMax.z), Point3d( ptMin.x, ptMin.y, ptMin.z)) ;
+      }
+     // se ridotto ad un rettangolo nel piano ZX
+      else if ( ( ptMax.y - ptMin.y) < EPS_SMALL) {
+        // giro a Ymin
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMin.z), Point3d( ptMax.x, ptMin.y, ptMin.z)) ;
+         Line2P( Point3d( ptMax.x, ptMin.y, ptMax.z), Point3d( ptMax.x, ptMin.y, ptMax.z)) ;
+         Line2P( Point3d( ptMax.x, ptMin.y, ptMax.z), Point3d( ptMin.x, ptMin.y, ptMax.z)) ;
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMax.z), Point3d( ptMin.x, ptMin.y, ptMin.z)) ;
+      }
+     // caso generico
+      else {
+        // giro a Zmin
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMin.z), Point3d( ptMax.x, ptMin.y, ptMin.z)) ;
+         Line2P( Point3d( ptMax.x, ptMin.y, ptMin.z), Point3d( ptMax.x, ptMax.y, ptMin.z)) ;
+         Line2P( Point3d( ptMax.x, ptMax.y, ptMin.z), Point3d( ptMin.x, ptMax.y, ptMin.z)) ;
+         Line2P( Point3d( ptMin.x, ptMax.y, ptMin.z), Point3d( ptMin.x, ptMin.y, ptMin.z)) ;
+        // giro a Zmax
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMax.z), Point3d( ptMax.x, ptMin.y, ptMax.z)) ;
+         Line2P( Point3d( ptMax.x, ptMin.y, ptMax.z), Point3d( ptMax.x, ptMax.y, ptMax.z)) ;
+         Line2P( Point3d( ptMax.x, ptMax.y, ptMax.z), Point3d( ptMin.x, ptMax.y, ptMax.z)) ;
+         Line2P( Point3d( ptMin.x, ptMax.y, ptMax.z), Point3d( ptMin.x, ptMin.y, ptMax.z)) ;
+        // giunzione tra i due giri
+         Line2P( Point3d( ptMin.x, ptMin.y, ptMin.z), Point3d( ptMin.x, ptMin.y, ptMax.z)) ;
+         Line2P( Point3d( ptMax.x, ptMin.y, ptMin.z), Point3d( ptMax.x, ptMin.y, ptMax.z)) ;
+         Line2P( Point3d( ptMax.x, ptMax.y, ptMin.z), Point3d( ptMax.x, ptMax.y, ptMax.z)) ;
+         Line2P( Point3d( ptMin.x, ptMax.y, ptMin.z), Point3d( ptMin.x, ptMax.y, ptMax.z)) ;
+      }
+   }
+
+   return true ;
+}