//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : ImportDxfEnts.cpp       Data : 11.05.14         Versione : 1.5e2
// Contenuto : Implementazione di ImportDxf : gestione delle entità.
//
//
//
// Modifiche : 17.04.14 DS Creazione modulo.
//             11.05.14 DS Agg. lettura SOLID.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ImportDxf.h"
#include "DxfColors.h"
#include "DxfConst.h"
#include "DllMain.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkCurveArc.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkCurveByInterp.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkGdbIterator.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EgtStringEncoder.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include <regex>

using namespace std ;

//----------------------------------------------------------------------------
const double RAY_LEN = 1000 ;

//----------------------------------------------------------------------------
bool
ImportDxf::ReadEntities( bool& bFileEnd)
{
  // ciclo di lettura
   bool bOk = true ;
   bool bSectEnd = false ;
   string sEntName ;
   do {
     // leggo intestazione entità, per avere il tipo
      bool bOkLoc = GetEntityName( sEntName, bSectEnd, bFileEnd) ;
      if ( bOkLoc  &&  ! bSectEnd) {
        // se Entità
         if ( ReadOneEntity( sEntName, bOkLoc, bFileEnd))
            ;
        // altrimenti ...
         else {
            string sOut = "ImportDxf : Skip entity " + sEntName +
                          " at line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_WARN( GetEExLogger(), sOut.c_str())
            if ( ! SkipEntity( bFileEnd))
               bOkLoc = false ;
         }
      }
     // gestisco eventuale errore
      if ( ! bOkLoc) {
         bOk = false ;
         string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
      }
   } while ( ! bSectEnd) ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadOneEntity( string& sEntName, bool& bOk, bool& bFileEnd)
{
  // se Faccia 3d
   if ( sEntName == "3DFACE") {
      if ( ! Read3dFace( bFileEnd))
         bOk = false ;
   }
  // se Arco
   else if ( sEntName == "ARC") {
      if ( ! ReadArc( bFileEnd))
         bOk = false ;
   }
  // se AttDef (da saltare)
   else if ( sEntName == "ATTDEF") {
      if ( ! SkipEntity( bFileEnd))
         bOk = false ;
   }
  // se Cerchio
   else if ( sEntName == "CIRCLE") {
      if ( ! ReadCircle( bFileEnd))
         bOk = false ;
   }
  // se Ellisse
   else if ( sEntName == "ELLIPSE") {
      if ( ! ReadEllipse( bFileEnd))
         bOk = false ;
   }
  // se Insert di Blocco
   else if ( sEntName == "INSERT") {
      if ( ! ReadInsert( bFileEnd))
         bOk = false ;
   }
  // se Linea
   else if ( sEntName == "LINE"  ||  sEntName == "3DLINE") {
      if ( ! ReadLine( bFileEnd))
         bOk = false ;
   }
  // se LwPolyLine
   else if ( sEntName == "LWPOLYLINE") {
      if ( ! ReadLwPolyLine( bFileEnd))
         bOk = false ;
   }
  // se MText
   else if ( sEntName == "MTEXT") {
      if ( ! ReadMText( bFileEnd))
         bOk = false ;
   }
  // se Punto
   else if ( sEntName == "POINT") {
      if ( ! ReadPoint( bFileEnd))
         bOk = false ;
   }
  // se PolyLine
   else if ( sEntName == "POLYLINE") {
      if ( ! ReadPolyLine( bFileEnd))
         bOk = false ;
   }
  // se Ray (semiretta)
   else if ( sEntName == "RAY") {
      if ( ! ReadRayXline( true, bFileEnd))
         bOk = false ;
   }
  // se 2D filled outline
   else if ( sEntName == "SOLID") {
      if ( ! ReadSolid( bFileEnd))
         bOk = false ;
   }
  // se Spline
   else if ( sEntName == "SPLINE") {
      if ( ! ReadSpline( bFileEnd))
         bOk = false ;
   }
  // se Text
   else if ( sEntName == "TEXT") {
      if ( ! ReadText( GDB_ID_NULL, bFileEnd))
         bOk = false ;
   }
  // se XLINE (linea infinita)
   else if ( sEntName == "XLINE") {
      if ( ! ReadRayXline( false, bFileEnd))
         bOk = false ;
   }
  // altrimenti
   else {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::GetEntityName( string& sEntName, bool& bSectEnd, bool& bFileEnd)
{
  // inizializzo
   sEntName.clear() ;
   bSectEnd = false ;
   bFileEnd = false ;
  // leggo il primo Item (mi aspetto 0 -> NomeEntità)
   int nCode = ReadNextItem() ;
   if ( nCode == CODE_NULL) {
      bSectEnd = true ;
      bFileEnd = true ;
      return false ;
   }
   if ( nCode != 0)
      return false ;
   if ( m_sCurrItem == "SECTION") {
      UngetItem() ;
      bSectEnd = true ;
      return true ;
   }
   if ( m_sCurrItem == "ENDSEC") {
      bSectEnd = true ;
      return true ;
   }
   if ( m_sCurrItem == "EOF") {
      bSectEnd = true ;
      bFileEnd = true ;
      return true ;
   }
   sEntName = m_sCurrItem ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::SkipEntity( bool& bFileEnd)
{
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item ( cerco 0 -> qualcosa)
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::SetColor( int nId, int nColor, const string& sLayer)
{
   Color cCol ;
   if ( ColorFromACI( nColor, cCol)) {
      if ( ! m_pGDB->SetMaterial( nId, cCol))
         return false ;
   }
   else if ( BlockReading()  &&  nColor == COL_BYLAYER  &&  sLayer != "0") {
      if ( m_pGDB->GetMaterial( GetLayerId( sLayer), cCol)) {
         if ( ! m_pGDB->SetMaterial( nId, cCol))
            return false ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::SetColorForInsert( int nId, int nIdS, const string& sLayer)
{
   Color cCol ;
   if ( m_pGDB->GetMaterial( nIdS, cCol)) {
      if ( ! m_pGDB->SetMaterial( nId, cCol))
         return false ;
   }
   else if ( sLayer != "0") {
      if ( m_pGDB->GetMaterial( GetLayerId( sLayer), cCol)) {
         if ( ! m_pGDB->SetMaterial( nId, cCol))
            return false ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ColorFromACI( int nColor, Color& cCol)
{
  // controllo i limiti dell'indice di colore ACI
   if ( nColor < 1  ||  nColor > 255)
      return false ;
  // assegno il colore
   cCol.Set( DxfColors[nColor][0], DxfColors[nColor][1], DxfColors[nColor][2]) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::Read3dFace( bool& bFileEnd)
{
   Point3d  ptP0 ;
   Point3d  ptP1 ;
   Point3d  ptP2 ;
   Point3d  ptP3 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item di 3dFace
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptP0.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP0.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP0.z) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, ptP1.x) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, ptP1.y) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, ptP1.z) ;
         break ;
      case 12 :
         FromString( m_sCurrItem, ptP2.x) ;
         break ;
      case 22 :
         FromString( m_sCurrItem, ptP2.y) ;
         break ;
      case 32 :
         FromString( m_sCurrItem, ptP2.z) ;
         break ;
      case 13 :
         FromString( m_sCurrItem, ptP3.x) ;
         break ;
      case 23 :
         FromString( m_sCurrItem, ptP3.y) ;
         break ;
      case 33 :
         FromString( m_sCurrItem, ptP3.z) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptP0 *= m_dScaleFactor ;
   ptP1 *= m_dScaleFactor ;
   ptP2 *= m_dScaleFactor ;
   ptP3 *= m_dScaleFactor ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptP0.ToLoc( m_frGroup) ;
      ptP1.ToLoc( m_frGroup) ; 
      ptP2.ToLoc( m_frGroup) ; 
      ptP3.ToLoc( m_frGroup) ;
   } 
  // verifico se 3 o 4 punti
   bool bQuad = ! AreSamePointApprox( ptP2, ptP3) ;
  // inserisco la faccia nel DB geometrico
   // creo la trimesh
   PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
   if ( IsNull( pSTM))
      return false ;
   // costruisco la geometria della trimesh
   if ( ! pSTM->Init( 4, 2))
      return false ;
   if ( pSTM->AddVertex( ptP0) == SVT_NULL  ||
        pSTM->AddVertex( ptP1) == SVT_NULL  ||
        pSTM->AddVertex( ptP2) == SVT_NULL  ||
        ( bQuad  &&  pSTM->AddVertex( ptP3) == SVT_NULL))
      return false ;
   int nIdVertT0[3] = { 0, 1, 2} ;
   int nIdVertT1[3] = { 2, 3, 0} ;
   if ( pSTM->AddTriangle( nIdVertT0) == SVT_NULL  ||
        ( bQuad  &&  pSTM->AddTriangle( nIdVertT1) == SVT_NULL))
      return false ;
   if ( ! pSTM->AdjustTopology())
      return false ;
  // se non ci sono triangoli, non inserisco la trimesh e proseguo senza errore
   if ( pSTM->GetTriangleCount() == 0)
      return true ;
  // inserisco la trimesh nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pSTM)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadArc( bool& bFileEnd)
{
   Point3d  ptCen ;
   double   dRadius ;
   double   dStartAng ;
   double   dEndAng ;
   Vector3d vtExtr = Z_AX ;
   double   dThick = 0 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item dell' arco
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptCen.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptCen.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptCen.z) ;
         break ;
      case 39 :
         FromString( m_sCurrItem, dThick) ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dRadius) ;
         break ;
      case 50 :
         FromString( m_sCurrItem, dStartAng) ;
         break ;
      case 51 :
         FromString( m_sCurrItem, dEndAng) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptCen *= m_dScaleFactor ;
   dRadius *= m_dScaleFactor ;
   dThick *= m_dScaleFactor ;
  // calcolo l'angolo al centro (archi sempre CCW in DXF)
   double dCentAng ;
   if ( abs( dEndAng - dStartAng) > ( 360. - EPS_ANG_SMALL))
      dCentAng = 360. ;
   else if ( dEndAng > dStartAng)
      dCentAng = dEndAng - dStartAng ;
   else
      dCentAng = dEndAng - dStartAng + 360. ;
  // se l'arco è nullo, non lo inserisco ma proseguo senza errore
   if ( dRadius < EPS_SMALL  ||  abs( dCentAng) < EPS_ANG_SMALL)
      return true ;
  // versore iniziale
   Vector3d vtStart = FromPolar( 1, dStartAng) ;
  // gestisco eventuale OCS
   if ( ! AreSameVectorExact( vtExtr, Z_AX)) {
      Frame3d frOCS ;
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
     // trasformo il centro e il versore iniziale
      ptCen.ToGlob( frOCS) ;
      vtStart.ToGlob( frOCS) ; 
   }
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptCen.ToLoc( m_frGroup) ;
      vtStart.ToLoc( m_frGroup) ;
      vtExtr.ToLoc( m_frGroup) ;
   } 
  // inserisco l'arco nel DB geometrico
   // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return false ;
   // setto l'arco
   if ( ! pCrvArc->Set( ptCen, vtExtr, dRadius, vtStart, dCentAng, 0))
      return false ;
   // eventuale impostazione vettore estrusione e spessore
   if ( abs( dThick) > EPS_SMALL) {
      pCrvArc->SetExtrusion( vtExtr) ;
      pCrvArc->SetThickness( dThick) ;
   }
  // inserisco l'arco nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvArc)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadCircle( bool& bFileEnd)
{
   Point3d  ptCen ;
   double   dRadius ;
   Vector3d vtExtr = Z_AX ;
   double   dThick = 0 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item della circonferenza
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptCen.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptCen.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptCen.z) ;
         break ;
      case 39 :
         FromString( m_sCurrItem, dThick) ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dRadius) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptCen *= m_dScaleFactor ;
   dRadius *= m_dScaleFactor ;
   dThick *= m_dScaleFactor ;
  // se il cerchio è nullo, non lo inserisco ma proseguo senza errore
   if ( dRadius < EPS_SMALL)
      return true ;
  // gestisco eventuale OCS
   if ( ! AreSameVectorExact( vtExtr, Z_AX)) {
      Frame3d frOCS ;
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
      ptCen.ToGlob( frOCS) ;
   }
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptCen.ToLoc( m_frGroup) ;
      vtExtr.ToLoc( m_frGroup) ;
   }
  // inserisco il cerchio nel DB geometrico
   // creo il cerchio
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return false ;
   // setto il cerchio
   if ( ! pCrvArc->Set( ptCen, vtExtr, dRadius))
      return false ;
   // eventuale impostazione vettore estrusione e spessore
   if ( abs( dThick) > EPS_SMALL) {
      pCrvArc->SetExtrusion( vtExtr) ;
      pCrvArc->SetThickness( dThick) ;
   }
  // inserisco il cerchio nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvArc)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadEllipse( bool& bFileEnd)
{
   Point3d  ptCen ;
   Vector3d vtMajorAx ;
   double   dRatMinMaj = 1 ;
   double   dStartPar = 0 ;
   double   dEndPar = 2 * PIGRECO ;
   Vector3d vtExtr = Z_AX ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item dell' arco
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptCen.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptCen.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptCen.z) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, vtMajorAx.x) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, vtMajorAx.y) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, vtMajorAx.z) ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dRatMinMaj) ;
         break ;
      case 41 :
         FromString( m_sCurrItem, dStartPar) ;
         break ;
      case 42 :
         FromString( m_sCurrItem, dEndPar) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptCen *= m_dScaleFactor ;
   vtMajorAx *= m_dScaleFactor ;
  // calcolo il semiasse maggiore
   double dMajorAx = vtMajorAx.Len() ;
   vtMajorAx.Normalize() ;
  // calcolo l'angolo al centro (ellisse sempre CCW in DXF)
   double dCentAng = ( dEndPar - dStartPar) * RADTODEG ;
  // se l'arco è nullo, non lo inserisco ma proseguo senza errore
   if ( dMajorAx < EPS_SMALL  ||  abs( dCentAng) < EPS_ANG_SMALL)
      return true ;
  // versore iniziale
   Vector3d vtStart = vtMajorAx ;
   vtStart.Rotate( vtExtr, dStartPar * RADTODEG) ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptCen.ToLoc( m_frGroup) ;
      vtMajorAx.ToLoc( m_frGroup) ;
      vtStart.ToLoc( m_frGroup) ; 
      vtExtr.ToLoc( m_frGroup) ;
   }
  // inserisco l'arco nel DB geometrico
   // creo l'arco
   PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
   if ( IsNull( pCrvArc))
      return false ;
   // setto l'arco
   if ( ! pCrvArc->Set( ptCen, vtExtr, dMajorAx, vtStart, dCentAng, 0))
      return false ;
  // inserisco l'arco nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvArc)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale scalatura
   if ( abs( dRatMinMaj - 1) > EPS_ZERO) {
      Frame3d frSca ;
      Vector3d vtY = vtExtr ^ vtMajorAx ;
      vtY.Normalize() ;
      if ( frSca.Set( ptCen, vtMajorAx, vtY, vtExtr))
         m_pGDB->Scale( nId, frSca, 1, dRatMinMaj, 1) ;
   }
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadInsert( bool& bFileEnd)
{
   InsertData insData ;
   int        nSpace = ENT_MODELSPACE ;
   int        nColor = COL_BYLAYER ;
   int        nHide = ENT_SHOW ;
   bool       bAttribs = false ;
  // ciclo di lettura degli item del punto
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 2 :
         insData.sName = m_sCurrItem ;
         break ;
      case 8 :
         insData.sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, insData.ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, insData.ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, insData.ptP.z) ;
         break ;
      case 41 :
         FromString( m_sCurrItem, insData.vtScale.x) ;
         break ;
      case 42 :
         FromString( m_sCurrItem, insData.vtScale.y) ;
         break ;
      case 43 :
         FromString( m_sCurrItem, insData.vtScale.z) ;
         break ;
      case 50 :
         FromString( m_sCurrItem, insData.dRotAngDeg) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 66 :
         FromString( m_sCurrItem, bAttribs) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, insData.vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, insData.vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, insData.vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE) {
      if ( bAttribs)
         return ReadInsertAttribs( false, GDB_ID_NULL, bFileEnd) ;
      return true ;
   }
  // eventuale aggiustamento del nome del blocco per caratteri non ammessi
   ValidateVal( insData.sName) ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( insData.sLayer) ;
  // aggiusto per il fattore di scala
   insData.ptP *= m_dScaleFactor ;
  // calcolo riferimento di inserimento
   Frame3d frOCS ;
   if ( ! AreSameVectorExact( insData.vtExtr, Z_AX)) {
      if ( ! frOCS.Set( ORIG, insData.vtExtr))
         return false ;
   }
  // recupero l'identificativo del blocco
   int nIdBlock = GetBlockId( insData.sName) ;
  // se blocco non trovato o non risolto 
   if ( nIdBlock == GDB_ID_NULL  ||  ! m_pGDB->ExistsInfo( nIdBlock, BLKOK_INFO)) {
     // se sono in lettura blocchi
      if ( BlockReading()) {
        // incremento contatore blocchi inseriti ma non risolti
         ++ m_nNumNotBokInCurrBlock ;
        // salvo un gruppo con i dati di inserimento
         int nId = m_pGDB->AddGroup( GDB_ID_NULL, GetGroupId( insData.sLayer), GLOB_FRM) ;
         if ( nId == GDB_ID_NULL  ||  ! SaveInsertInfo( nId, insData))
            return false ;
        // se previsto, leggo eventuali attributi dipendenti dall'inserimento del blocco
         if ( bAttribs)
            return ReadInsertAttribs( true, GetGroupId( insData.sLayer), bFileEnd) ;
         return true ;
      }
     // altrimenti errore
      else
         return false ;
   }
  // recupero il punto base del blocco per determinare lo spostamento
   Point3d ptBase ;
   m_pGDB->GetInfo( nIdBlock, POINT_INFO, ptBase) ;
   Vector3d vtMove = insData.ptP - ptBase ;
  // copio tutte le entità del blocco, trasformandole opportunamente
   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGDB)) ;
   if ( IsNull( pIter))
      return false ;
   bool bFound = pIter->GoToFirstInGroup( nIdBlock) ;
   while ( bFound) {
     // copio l'entità geometrica
      IGeoObj* pGeoS = pIter->GetGeoObj() ;
      if ( pGeoS == nullptr)
         return false ;
      PtrOwner<IGeoObj> pGeo( pGeoS->Clone()) ;
      if ( IsNull( pGeo))
         return false ;
     // inserisco l'entità nel DB
      int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( insData.sLayer), Release( pGeo)) ;
      if ( nId == GDB_ID_NULL)
         return false ;
     // eseguo le opportune trasformazioni
      m_pGDB->Scale( nId, Frame3d( ptBase), insData.vtScale.x, insData.vtScale.y, insData.vtScale.z) ;
      m_pGDB->Rotate( nId, ptBase, Z_AX, insData.dRotAngDeg) ; 
      m_pGDB->Translate( nId, vtMove) ;
      m_pGDB->GetGeoObj( nId)->ToGlob( frOCS) ;
      if ( ! BlockReading())
         m_pGDB->GetGeoObj( nId)->ToLoc( m_frGroup) ;
     // recupero il colore
      if ( ! SetColorForInsert( nId, pIter->GetId(), insData.sLayer))
         return false ;
     // passo alla successiva
      bFound = pIter->GoToNext() ;
   }
  // se previsto, leggo eventuali attributi dipendenti dall'inserimento del blocco
   if ( bAttribs)
      return ReadInsertAttribs( true, GetGroupId( insData.sLayer), bFileEnd) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadInsertAttribs( bool bSave, int nGroupId, bool& bFileEnd)
{
  // Ciclo sugli Attrib, termino con SEQEND o errore
   bFileEnd = false ;
   bool bAttribsEnd = false ;
   string sEntName ;
   do {
     // leggo intestazione entità, per avere il tipo
      bool bOkLoc = GetEntityName( sEntName, bAttribsEnd, bFileEnd) ;
      if ( bOkLoc  &&  ! bAttribsEnd) {
        // se Attrib
         if ( sEntName == "ATTRIB") {
            if ( bSave) {
               if ( ! ReadText( nGroupId, bFileEnd))
                  bOkLoc = false ;
            }
            else {
               if ( ! SkipEntity( bFileEnd))
                  bOkLoc = false ;
            }
         }
        // se SeqEnd
         else if ( sEntName == "SEQEND") {
            if ( ! SkipEntity( bFileEnd))
               bOkLoc = false ;
            bAttribsEnd = true ;
         }
        // altrimenti errore
         else {
            UngetItem() ;
            return false ;
         }
      }
     // gestisco eventuale errore
      if ( ! bOkLoc) {
         string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
         return false ;
      }
   } while( ! bAttribsEnd) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadLine( bool& bFileEnd)
{
   Point3d  ptStart ;
   Point3d  ptEnd ;
   Vector3d vtExtr = Z_AX ;
   double   dThick = 0 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptStart.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptStart.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptStart.z) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, ptEnd.x) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, ptEnd.y) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, ptEnd.z) ;
         break ;
      case 39 :
         FromString( m_sCurrItem, dThick) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptStart *= m_dScaleFactor ;
   ptEnd *= m_dScaleFactor ;
   dThick *= m_dScaleFactor ;
  // se la linea è nulla, non la inserisco ma proseguo senza errore
   if ( AreSamePointEpsilon( ptStart, ptEnd, 2 * EPS_SMALL))
      return true ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptStart.ToLoc( m_frGroup) ;
      ptEnd.ToLoc( m_frGroup) ; 
   }
  // inserisco la linea nel DB geometrico
   // creo la linea
   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
   if ( IsNull( pCrvLine))
      return false ;
   // setto la linea
   if ( ! pCrvLine->Set( ptStart, ptEnd))
      return false ;
   // eventuale impostazione vettore estrusione e spessore
   if ( abs( dThick) > EPS_SMALL) {
      pCrvLine->SetExtrusion( vtExtr) ;
      pCrvLine->SetThickness( dThick) ;
   }
  // inserisco la linea nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvLine)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadRayXline( bool bIsRay, bool& bFileEnd)
{
   Point3d  ptRef ;
   Vector3d vtDir ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item della Xlinea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptRef.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptRef.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptRef.z) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, vtDir.x) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, vtDir.y) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, vtDir.z) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptRef *= m_dScaleFactor ;
  // se la linea è nulla, non la inserisco ma proseguo senza errore
   if ( vtDir.IsSmall())
      return true ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptRef.ToLoc( m_frGroup) ;
      vtDir.ToLoc( m_frGroup) ; 
   }
  // inserisco la linea nel DB geometrico
   // creo la linea
   PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
   if ( IsNull( pCrvLine))
      return false ;
   // setto la linea
   Point3d ptStart = ptRef ;
   if ( ! bIsRay)
      ptStart -= RAY_LEN * vtDir ;
   Point3d ptEnd = ptRef + RAY_LEN * vtDir ;
   if ( ! pCrvLine->Set( ptStart, ptEnd))
      return false ;
  // inserisco la linea nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvLine)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadLwPolyLine( bool& bFileEnd)
{
   PolyArc  PA ;
   Vector3d vtExtr = Z_AX ;
   double   dElevation = 0 ;
   double   dThick = 0 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
   int      nNumVert = 0 ;
   int      nFlag = 0 ;
   Point3d  ptV ;
   double   dBulge = 0 ;
  // ciclo di lettura degli item della LwPolyLine
   bFileEnd = false ;
   int nContX = 0 ;
   int nContY = 0 ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptV.x) ;
         ++ nContX ;
         if ( nContX == nContY)
            PA.AddUPoint( 0, ptV, 0) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptV.y) ;
         ++ nContY ;
         if ( nContX == nContY)
            PA.AddUPoint( 0, ptV, 0) ;
         break ;
      case 38 :
         FromString( m_sCurrItem, dElevation) ;
         break ;
      case 39 :
         FromString( m_sCurrItem, dThick) ;
         break ;
      case 42 :
         FromString( m_sCurrItem, dBulge) ;
         PA.ModifyLastBulge( dBulge) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 70 :
         FromString( m_sCurrItem, nFlag) ;
         break ;
      case 90 :
         FromString( m_sCurrItem, nNumVert) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // Verifico il numero di vertici
   if ( ( PA.GetPointNbr() + PA.GetRejectedNbr()) != nNumVert)
      return false ;
   if ( PA.GetPointNbr() < 2)
      return true ;
  // Se chiusa, aggiungo un punto uguale al primo in coda
   if ( nFlag & 1) {
      if ( PA.Close())
         ++ nNumVert ;
   }
  // aggiusto per il fattore di scala
   dElevation *= m_dScaleFactor ;
   dThick *= m_dScaleFactor ;
   PA.Scale( GLOB_FRM, m_dScaleFactor) ;
  // aggiusto i punti per elevazione, eventuale OCS e riferimento del gruppo di inserimento
   Frame3d frOCS ;
   if ( ! AreSameVectorExact( vtExtr, Z_AX)) {
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
   }
   PA.SetElevation( dElevation) ;
   PA.ToGlob( frOCS) ;
   if ( ! BlockReading())
      PA.ToLoc( m_frGroup) ;
  // Creo la curva composita
   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
   if ( IsNull( pCrvCompo))
      return false ;
  // Inserisco i punti con bulge nella curva composita come linee e archi
   if ( ! pCrvCompo->FromPolyArc( PA))
      return false ;
  // Se non sono state inserite curve, esco senza errore
   if ( pCrvCompo->GetCurveCount() == 0)
      return true ;
   // eventuale impostazione vettore estrusione e spessore
   if ( abs( dThick) > EPS_SMALL) {
      pCrvCompo->SetExtrusion( vtExtr) ;
      pCrvCompo->SetThickness( dThick) ;
   }
  // Inserisco la curva composita nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvCompo)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadPoint( bool& bFileEnd)
{
   Point3d  ptP ;
   Vector3d vtExtr = Z_AX ;
   double   dThick = 0 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item del punto
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         break ;
      case 39 :
         FromString( m_sCurrItem, dThick) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptP *= m_dScaleFactor ;
   dThick *= m_dScaleFactor ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading())
      ptP.ToLoc( m_frGroup) ;
  // inserisco l'entità nel DB geometrico
   PtrOwner<IGeoObj> pGeoObj ;  ;
   if ( abs( dThick) < EPS_SMALL) {
     // creo il punto
      PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
      if ( IsNull( pGeoPnt))
         return false ;
     // setto il punto
      if ( ! pGeoPnt->Set( ptP))
         return false ;
     // lo passo all'oggetto geometrico generico
      pGeoObj.Set( pGeoPnt) ;
   }
   else {
     // creo il vettore con punto base
      PtrOwner<IGeoVector3d> pGeoVect( CreateGeoVector3d()) ;
      if ( IsNull( pGeoVect))
         return false ;
     // setto il punto
      if ( ! pGeoVect->Set( dThick * vtExtr, ptP))
         return false ;
     // lo passo all'oggetto geometrico generico
      pGeoObj.Set( pGeoVect) ;
   }
   // inserisco l'entità nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pGeoObj)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
   // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadPolyLine( bool& bFileEnd)
{
   Vector3d vtExtr = Z_AX ;
   double   dElevation = 0 ;
   double   dThick = 0 ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
   int      nFlag = 0 ;
   int      nNumVertM = 0 ;
   int      nNumVertN = 0 ;
  // ciclo di lettura degli item della PolyLine
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 30 :
         FromString( m_sCurrItem, dElevation) ;
         break ;
      case 39 :
         FromString( m_sCurrItem, dThick) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 70 :
         FromString( m_sCurrItem, nFlag) ;
         break ;
      case 71 :
         FromString( m_sCurrItem, nNumVertM) ;
         break ;
      case 72 :
         FromString( m_sCurrItem, nNumVertN) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   bool bToSave = true ;
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      bToSave = false ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // Se Polygon Mesh
   if ( ( nFlag & 16) != 0)
      return CompletePolygonMesh( sLayer, nColor, nFlag, bToSave,
                                  dElevation, vtExtr, nNumVertM, nNumVertN, bFileEnd) ;
  // se Polyface Mesh
   else if ( ( nFlag & 64) != 0)
      return CompletePolyfaceMesh( sLayer, nColor, nFlag, bToSave, dElevation, vtExtr, bFileEnd) ;
  // altrimenti PolyLine vera e propria
   else
      return CompletePolyLine( sLayer, nColor, nFlag, bToSave, dElevation, dThick, vtExtr, bFileEnd) ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::CompletePolyLine( const string& sLayer, int nColor, int nFlag, bool bToSave,
                             double dElevation, double dThick, const Vector3d& vtExtr, bool& bFileEnd)
{
   int  nNumVert = 0 ;
   PolyArc PA ;
   Point3d ptV ;
   double  dBulge = 0 ;
  // Ciclo sui Vertex, termino con SEQEND o errore
   bFileEnd = false ;
   bool bIs3d = (( nFlag & 8) != 0) ;
   bool bPolyEnd = false ;
   string sEntName ;
   do {
     // leggo intestazione entità, per avere il tipo
      bool bOkLoc = GetEntityName( sEntName, bPolyEnd, bFileEnd) ;
      if ( bOkLoc  &&  ! bPolyEnd) {
        // se Vertex
         if ( sEntName == "VERTEX") {
            if ( ! ReadPolyLineVertex( ptV, dBulge, bFileEnd))
               bOkLoc = false ;
           // se polilinea 3d non sono ammessi archi (bulge = 0)
            if ( bIs3d)
               dBulge = 0 ;
           // altrimenti polilinea 2d quindi z = 0
            else
               ptV.z = 0 ;
            PA.AddUPoint( 0, ptV, dBulge) ;
            nNumVert ++ ;
         }
        // se SeqEnd
         else if ( sEntName == "SEQEND") {
            if ( ! SkipEntity( bFileEnd))
               bOkLoc = false ;
            bPolyEnd = true ;
         }
        // altrimenti errore
         else {
            UngetItem() ;
            return false ;
         }
      }
     // gestisco eventuale errore
      if ( ! bOkLoc) {
         string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
         return false ;
      }
   } while( ! bPolyEnd) ;

  // se entità da saltare, esco
   if ( ! bToSave)
      return true ;
  // Verifico il numero di vertici
   if ( ( PA.GetPointNbr() + PA.GetRejectedNbr()) != nNumVert)
      return false ;
   if ( PA.GetPointNbr() < 2)
      return true ;
  // Se chiusa, aggiungo un punto uguale al primo in coda
   if ( nFlag & 1) {
      if ( PA.Close())
         ++ nNumVert ;
   }
  // aggiusto per il fattore di scala
   dElevation *= m_dScaleFactor ;
   dThick *= m_dScaleFactor ;
   PA.Scale( GLOB_FRM, m_dScaleFactor) ;
  // aggiusto i punti per elevazione, eventuale OCS e riferimento del gruppo di inserimento
   Frame3d frOCS ;
   if ( ! bIs3d  &&  ! AreSameVectorExact( vtExtr, Z_AX)) {
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
   }
   PA.AddElevation( dElevation) ;
   PA.ToGlob( frOCS) ;
   if ( ! BlockReading())
      PA.ToLoc( m_frGroup) ;
  // Creo la curva composita
   PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
   if ( IsNull( pCrvCompo))
      return false ;
  // Inserisco i punti con bulge nella curva composita come linee e archi
   if ( ! pCrvCompo->FromPolyArc( PA))
      return false ;
  // Se non sono state inserite curve, esco senza errore
   if ( pCrvCompo->GetCurveCount() == 0)
      return true ;
   // eventuale impostazione vettore estrusione e spessore
   if ( abs( dThick) > EPS_SMALL) {
      pCrvCompo->SetExtrusion( vtExtr) ;
      pCrvCompo->SetThickness( dThick) ;
   }
  // Inserisco la curva composita nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrvCompo)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadPolyLineVertex( Point3d& ptP, double& dBulge, bool& bFileEnd)
{
  // inizializzo il punto con bulge
   ptP.Set( 0, 0, 0) ;
   dBulge = 0 ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         break ;
      case 42 :
         FromString( m_sCurrItem, dBulge) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::CompletePolygonMesh( const string& sLayer, int nColor, int nFlag, bool bToSave,
                   double dElevation, const Vector3d& vtExtr, int nNumVertM, int nNumVertN, bool& bFileEnd)
{
  // creo la superficie
   PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
   if ( IsNull( pSTM))
      return false ;
  // la inizializzo
   int nNumVert = nNumVertM * nNumVertN ;
   bool bClosedM = (( nFlag & 1) != 0) ;
   bool bClosedN = (( nFlag & 32) != 0) ;
   int nNumTria = 0 ;
   if ( bClosedM  &&  bClosedN)
      nNumTria = 2 * nNumVertM * nNumVertN ;
   else if ( bClosedM)
      nNumTria = 2 * nNumVertM * ( nNumVertN - 1) ;
   else if ( bClosedN)
      nNumTria = 2 * ( nNumVertM - 1) * nNumVertN ;
   else
      nNumTria = 2 * ( nNumVertM - 1) * ( nNumVertN - 1) ;
   if ( ! pSTM->Init( nNumVert, nNumTria))
      return false ;
  // determino eventuale OCS
   Frame3d frOCS ;
   if ( ! ( nFlag & 8)  &&  ! AreSameVectorExact( vtExtr, Z_AX)) {
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
   }

  // Ciclo sui Vertex, termino con SEQEND o errore
   bFileEnd = false ;
   bool bPolyEnd = false ;
   int  nReadVert = 0 ;
   string sEntName ;
   Point3d ptP ;
   do {
     // leggo intestazione entità, per avere il tipo
      bool bOkLoc = GetEntityName( sEntName, bPolyEnd, bFileEnd) ;
      if ( bOkLoc  &&  ! bPolyEnd) {
        // se Vertex
         if ( sEntName == "VERTEX") {
           // leggo il punto
            if ( ! ReadPolygonMeshVertex( ptP, bFileEnd))
               bOkLoc = false ;
           // aggiusto per il fattore di scala
            ptP *= m_dScaleFactor ;
           // sistemazioni per elevazione, eventuale OCS e riferimento del gruppo di inserimento
            ptP.z += dElevation ;
            ptP.ToGlob( frOCS) ;
            if ( ! BlockReading())
               ptP.ToLoc( m_frGroup) ;
           // inserimento del vertice nella trimesh
            if ( pSTM->AddVertex( ptP) == SVT_NULL)
               return false ;
            nReadVert ++ ;
         }
        // se SeqEnd
         else if ( sEntName == "SEQEND") {
            if ( ! SkipEntity( bFileEnd))
               bOkLoc = false ;
            bPolyEnd = true ;
         }
        // altrimenti errore
         else {
            UngetItem() ;
            return false ;
         }
      }
     // gestisco eventuale errore
      if ( ! bOkLoc) {
         string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
         return false ;
      }
   } while( ! bPolyEnd) ;

  // Se entità da saltare, esco
   if ( ! bToSave)
      return true ;
  // Verifico il numero di vertici
   if ( nNumVert != nReadVert)
      return false ;
  // Definisco i triangoli
   int nMmax = ( bClosedM ? nNumVertM : ( nNumVertM - 1)) ;
   int nNmax = ( bClosedN ? nNumVertN : ( nNumVertN - 1)) ;
   int nIdVT1[3] ;
   int nIdVT2[3] ;
   for ( int i = 0 ; i < nMmax ; ++ i) {
      for ( int j = 0 ; j < nNmax ; ++ j) {
        // primo triangolo
         nIdVT1[0] = i * nNumVertN + j ;
         nIdVT1[1] = (( j < nNumVertN - 1) ? ( nIdVT1[0] + 1) : ( i * nNumVertN)) ;
         nIdVT1[2] = (( i < nNumVertM - 1) ? ( nIdVT1[1] + nNumVertN) : ( j + 1)) ;
        // secondo triangolo
         nIdVT2[0] = nIdVT1[0] ;
         nIdVT2[1] = nIdVT1[2] ;
         nIdVT2[2] = (( i < nNumVertM - 1) ? ( nIdVT2[0] + nNumVertN) : j) ;
        // inserisco i triangoli nella trimesh
         if ( pSTM->AddTriangle( nIdVT1) == SVT_NULL  ||
              pSTM->AddTriangle( nIdVT2) == SVT_NULL)
            return false ;
      }
   }
  // valido la superficie e calcolo le adiacenze
   if ( ! pSTM->AdjustTopology())
      return false ;
  // se non ci sono triangoli, non inserisco la trimesh e proseguo senza errore
   if ( pSTM->GetTriangleCount() == 0)
      return true ;
  // inserisco la trimesh nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pSTM)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadPolygonMeshVertex( Point3d& ptP, bool& bFileEnd)
{
  // inizializzo il punto
   ptP.Set( 0, 0, 0) ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::CompletePolyfaceMesh( const string& sLayer, int nColor, int nFlag, bool bToSave,
                                 double dElevation, const Vector3d& vtExtr, bool& bFileEnd)
{
  // creo la superficie
   PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
   if ( IsNull( pSTM))
      return false ;
  // la inizializzo
   if ( ! pSTM->Init( 3, 1))
      return false ;
  // determino eventuale OCS
   Frame3d frOCS ;
   if ( ! ( nFlag & 8)  &&  ! AreSameVectorExact( vtExtr, Z_AX)) {
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
   }

  // Ciclo sui Vertex, termino con SEQEND o errore
   bFileEnd = false ;
   bool bPolyEnd = false ;
   string sEntName ;
   int nStat ;
   Point3d ptP ;
   int nIdVT1[3], nIdVT2[3] ;
   do {
     // leggo intestazione entità, per avere il tipo
      bool bOkLoc = GetEntityName( sEntName, bPolyEnd, bFileEnd) ;
      if ( bOkLoc  &&  ! bPolyEnd) {
        // se Vertex
         if ( sEntName == "VERTEX") {
           // leggo il punto
            if ( ! ReadPolyfaceMeshVertex( nStat, ptP, nIdVT1, nIdVT2, bFileEnd))
               bOkLoc = false ;
            switch ( nStat) {
            case 0 :      // è un vertice
              // aggiusto per il fattore di scala
               ptP *= m_dScaleFactor ;
              // sistemazioni per elevazione, eventuale OCS e riferimento del gruppo di inserimento
               ptP.z += dElevation ;
               ptP.ToGlob( frOCS) ;
               if ( ! BlockReading())
                  ptP.ToLoc( m_frGroup) ;
              // inserimento del vertice nella trimesh
               if ( pSTM->AddVertex( ptP) == SVT_NULL)
                  return false ;
               break ;
            case 1 :      // è un triangolo
              // inserimento del triangolo nella trimesh
               if ( pSTM->AddTriangle( nIdVT1) == SVT_NULL)
                  return false ;
               break ;
            case 2 :      // sono due triangoli
              // inserimento dei triangoli nella trimesh
               if ( pSTM->AddTriangle( nIdVT1) == SVT_NULL  ||
                    pSTM->AddTriangle( nIdVT2) == SVT_NULL)
                  return false ;
            }
         }
        // se SeqEnd
         else if ( sEntName == "SEQEND") {
            if ( ! SkipEntity( bFileEnd))
               bOkLoc = false ;
            bPolyEnd = true ;
         }
        // altrimenti errore
         else {
            UngetItem() ;
            return false ;
         }
      }
     // gestisco eventuale errore
      if ( ! bOkLoc) {
         string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
         return false ;
      }
   } while( ! bPolyEnd) ;

  // se entità da saltare, esco
   if ( ! bToSave)
      return true ;
  // valido la superficie e calcolo le adiacenze
   if ( ! pSTM->AdjustTopology())
      return false ;
  // se non ci sono triangoli, non inserisco la trimesh e proseguo senza errore
   if ( pSTM->GetTriangleCount() == 0)
      return true ;
  // inserisco la trimesh nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pSTM)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadPolyfaceMeshVertex( int& nStat, Point3d& ptP, int nIdVT1[3], int nIdVT2[3], bool& bFileEnd)
{
  // inizializzo il punto e gli indici
   ptP.Set( 0, 0, 0) ;
   nIdVT1[0] = - 1 ; nIdVT1[1] = - 1 ; nIdVT1[2] = - 1 ;
   nIdVT2[0] = - 1 ; nIdVT2[1] = - 1 ; nIdVT2[2] = - 1 ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nFlag = 0 ;
   int nVal = 0 ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         break ;
      case 70 :
         FromString( m_sCurrItem, nFlag) ;
         break ;
      case 71 :
         FromString( m_sCurrItem, nVal) ;
         nIdVT1[0] = abs( nVal) - 1 ;       // in DXF indici 1 based, in STM 0 based
         break ;                            // (negativi indicano edge nascosto)
      case 72 :
         FromString( m_sCurrItem, nVal) ;
         nIdVT1[1] = abs( nVal) - 1 ;
         break ;
      case 73 :
         FromString( m_sCurrItem, nVal) ;
         nIdVT1[2] = abs( nVal) - 1 ;
         break ;
      case 74 :
         FromString( m_sCurrItem, nVal) ;
         nIdVT2[2] = abs( nVal) - 1 ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se è un vertice
   if ( ( nFlag & 128) != 0  &&  ( nFlag & 64) != 0)
      nStat = 0 ;
  // se è una faccia (formata da uno o due triangoli)
   else if ( ( nFlag & 128) != 0) {
     // se non c'è il secondo triangolo
      if ( nIdVT2[2] == - 1)
         nStat = 1 ;
      else {
         nStat = 2 ;
         nIdVT2[0] = nIdVT1[0] ;
         nIdVT2[1] = nIdVT1[2] ;
      }
   }
  // altrimenti nulla
   else
      nStat = - 1 ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadSolid( bool& bFileEnd)
{
   Point3d  ptP0 ;
   Point3d  ptP1 ;
   Point3d  ptP2 ;
   Point3d  ptP3 ;
   Vector3d vtExtr = Z_AX ;
   string   sLayer ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item di SOLID
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptP0.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP0.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP0.z) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, ptP1.x) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, ptP1.y) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, ptP1.z) ;
         break ;
      case 12 :
         FromString( m_sCurrItem, ptP2.x) ;
         break ;
      case 22 :
         FromString( m_sCurrItem, ptP2.y) ;
         break ;
      case 32 :
         FromString( m_sCurrItem, ptP2.z) ;
         break ;
      case 13 :
         FromString( m_sCurrItem, ptP3.x) ;
         break ;
      case 23 :
         FromString( m_sCurrItem, ptP3.y) ;
         break ;
      case 33 :
         FromString( m_sCurrItem, ptP3.z) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // aggiusto per il fattore di scala
   ptP0 *= m_dScaleFactor ;
   ptP1 *= m_dScaleFactor ;
   ptP2 *= m_dScaleFactor ;
   ptP3 *= m_dScaleFactor ;
  // gestisco eventuale OCS
   if ( ! AreSameVectorExact( vtExtr, Z_AX)) {
      Frame3d frOCS ;
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
     // trasformo i punti
      ptP0.ToGlob( frOCS) ;
      ptP1.ToGlob( frOCS) ; 
      ptP2.ToGlob( frOCS) ; 
      ptP3.ToGlob( frOCS) ; 
   }
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptP0.ToLoc( m_frGroup) ;
      ptP1.ToLoc( m_frGroup) ; 
      ptP2.ToLoc( m_frGroup) ; 
      ptP3.ToLoc( m_frGroup) ;
   } 
  // verifico se 3 o 4 punti
   bool bQuad = ! AreSamePointApprox( ptP2, ptP3) ;
  // inserisco la faccia nel DB geometrico
   // creo la trimesh
   PtrOwner<ISurfTriMesh> pSTM( CreateSurfTriMesh()) ;
   if ( IsNull( pSTM))
      return false ;
   // costruisco la geometria della trimesh
   if ( ! pSTM->Init( 4, 2))
      return false ;
   if ( pSTM->AddVertex( ptP0) == SVT_NULL  ||
        pSTM->AddVertex( ptP1) == SVT_NULL  ||
        pSTM->AddVertex( ptP2) == SVT_NULL  ||
        ( bQuad  &&  pSTM->AddVertex( ptP3) == SVT_NULL))
      return false ;
   int nIdVertT0[3] = { 0, 1, 2} ;
   int nIdT0 = pSTM->AddTriangle( nIdVertT0) ;
   int nIdVertT1[3] = { 2, 1, 3} ;
   int nIdT1 = ( bQuad ? pSTM->AddTriangle( nIdVertT1) : SVT_DEL) ;
   if ( nIdT0 == SVT_NULL  ||  nIdT1 == SVT_NULL)
      return false ;
   if ( nIdT0 == SVT_DEL  &&  nIdT1 == SVT_DEL)
      return true ;
   if ( ! pSTM->AdjustTopology())
      return false ;
  // se non ci sono triangoli, non inserisco la trimesh e proseguo senza errore
   if ( pSTM->GetTriangleCount() == 0)
      return true ;
  // inserisco la trimesh nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pSTM)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadSpline( bool& bFileEnd)
{
   CNurbsData cnData ;
   cnData.vU.reserve( 16) ; 
   cnData.vCP.reserve( 16) ; 
   cnData.vW.reserve( 16) ;
   PNTVECTOR vIntPnt ; 
   double    dTemp ;
   Point3d   ptP ;
   Point3d   ptInt ;
   string    sLayer ;
   int       nSpace = ENT_MODELSPACE ;
   int       nColor = COL_BYLAYER ;
   int       nHide = ENT_SHOW ;
   int       nKnotNbr = 0 ;
   int       nCPntNbr = 0 ;
   int       nIPntNbr = 0 ;
   int       nFlag = 0 ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nContX = 0 ;
   int nContY = 0 ;
   int nContZ = 0 ;
   int nIntX = 0 ;
   int nIntY = 0 ;
   int nIntZ = 0 ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         ++ nContX ;
         if ( nContX == nContY  &&  nContY == nContZ)
            cnData.vCP.push_back( ptP) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         ++ nContY ;
         if ( nContX == nContY  &&  nContY == nContZ)
            cnData.vCP.push_back( ptP) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         ++ nContZ ;
         if ( nContX == nContY  &&  nContY == nContZ)
            cnData.vCP.push_back( ptP) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, ptInt.x) ;
         ++ nIntX ;
         if ( nIntX == nIntY  &&  nIntY == nIntZ)
            vIntPnt.push_back( ptInt) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, ptInt.y) ;
         ++ nIntY ;
         if ( nIntX == nIntY  &&  nIntY == nIntZ)
            vIntPnt.push_back( ptInt) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, ptInt.z) ;
         ++ nIntZ ;
         if ( nIntX == nIntY  &&  nIntY == nIntZ)
            vIntPnt.push_back( ptInt) ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dTemp) ;
         cnData.vU.push_back( dTemp) ;
         break;
      case 41 :
         FromString( m_sCurrItem, dTemp) ;
         cnData.vW.push_back( dTemp) ;
         break;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 70 :
         FromString( m_sCurrItem, nFlag) ;
         break ;
      case 71 :
         FromString( m_sCurrItem, cnData.nDeg) ;
         break ;
      case 72 :
         FromString( m_sCurrItem, nKnotNbr) ;
         break ;
      case 73 :
         FromString( m_sCurrItem, nCPntNbr) ;
         break ;
      case 74 :
         FromString( m_sCurrItem, nIPntNbr) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // se spline con soli punti di interpolazione
   if ( ( cnData.vU.size() == 0  ||  cnData.vCP.size() == 0)  &&
        vIntPnt.size() == nIPntNbr  &&  nIPntNbr >= 2) {
     // se curva chiusa e l'ultimo punto non uguaglia il primo, copio il primo in coda
      if ( (( nFlag & SPL_CLOSED) != 0)  &&  ! AreSamePointApprox( vIntPnt.front(), vIntPnt.back()))
         vIntPnt.push_back( vIntPnt.front()) ;
     // aggiusto per il fattore di scala
      for ( int i = 0 ; i < nIPntNbr ; ++i)
         vIntPnt[i] *= m_dScaleFactor ;
     // gestisco il riferimento del gruppo di inserimento
      if ( ! BlockReading()) {
         for ( int i = 0 ; i < nIPntNbr ; ++i)
            vIntPnt[i].ToLoc( m_frGroup) ;
      }
     // calcolo la curva interpolata
      CurveByInterp crvByInterp ;
      for ( int i = 0 ; i < int( vIntPnt.size()) ; ++ i)
         crvByInterp.AddPoint( vIntPnt[i]) ;
      PtrOwner<ICurve> pCrv( crvByInterp.GetCurve( CurveByInterp::BESSEL, CurveByInterp::CUBIC_BEZIERS)) ;
      if ( IsNull( pCrv))
         return false ;
     // Inserisco la curva nel DB
      int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrv)) ;
      if ( nId == GDB_ID_NULL)
         return false ;
     // eventuale assegnazione del colore
      if ( ! SetColor( nId, nColor, sLayer))
         return false ;
      return true ;
   }
  // assegnazione flag
   cnData.bRat = (( nFlag & SPL_RATIONAL) != 0) ;
   cnData.bPeriodic = (( nFlag & SPL_PERIODIC) != 0  &&  ( nKnotNbr != nCPntNbr + cnData.nDeg + 1)) ;
   cnData.bClosed = (( nFlag & SPL_CLOSED) != 0) ;
   cnData.bClamped = true ;
   cnData.bExtraKnotes = true ;
  // Verifico il numero di nodi
   if ( cnData.vU.size() != nKnotNbr  ||  nKnotNbr < 4)
      return false ;
  // Verifico il numero di punti di controllo
   if ( cnData.vCP.size() != nCPntNbr  ||  nCPntNbr < 2)
      return false ;
  // Verifico il numero dei pesi
   if ( cnData.bRat  &&  cnData.vW.size() != nCPntNbr)
      return false ;
  // aggiusto per il fattore di scala
   for ( int i = 0 ; i < nCPntNbr ; ++i)
      cnData.vCP[i] *= m_dScaleFactor ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      for ( int i = 0 ; i < nCPntNbr ; ++i)
         cnData.vCP[i].ToLoc( m_frGroup) ;
   }
  // rendo canonica la rappresentazione della curva Nurbs
   if ( ! NurbsCurveCanonicalize( cnData))
      return false ;
  // creo la curva equivalente alla Nurbs
   PtrOwner<ICurve> pCrv( NurbsToBezierCurve( cnData)) ;
   if ( IsNull( pCrv))
      return false ;
   if ( ! pCrv->IsValid())
      return true ;
  // Inserisco la curva composita nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pCrv)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadText( int nGroupId, bool& bFileEnd)
{
   Point3d  ptP ;
   Vector3d vtExtr = Z_AX ;
   string   sText ;
   string   sLayer ;
   string   sStyle = "STANDARD" ;
   double   dH ;
   double   dAngDeg = 0 ;
   double   dRat = 1 ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 1 :
         sText = m_sCurrItem ;
         break ;
      case 7 :
         sStyle = m_sCurrItem ;
         break ;
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dH) ;
         break ;
      case 41 :
         FromString( m_sCurrItem, dRat) ;
         break ;
      case 50 :
         FromString( m_sCurrItem, dAngDeg) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // eventuale aggiustamento dello stile per caratteri non ammessi e trasformazione in maiuscolo
   ValidateVal( sStyle) ;
   ToUpper( sStyle) ;
  // aggiusto per il fattore di scala
   ptP *= m_dScaleFactor ;
   dH *= m_dScaleFactor ;
  // versore iniziale
   Vector3d vtDir = FromPolar( 1, dAngDeg) ;
  // gestisco eventuale OCS
   if ( ! AreSameVectorExact( vtExtr, Z_AX)) {
      Frame3d frOCS ;
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
     // trasformo il centro e il versore iniziale
      ptP.ToGlob( frOCS) ;
      vtDir.ToGlob( frOCS) ; 
   }
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptP.ToLoc( m_frGroup) ;
      vtExtr.ToLoc( m_frGroup) ;
      vtDir.ToLoc( m_frGroup) ;
   }
  // aggiusto i caratteri
   AdjustText( sText) ;
  // se testo è nullo, non lo inserisco ma proseguo senza errore
   if ( sText.empty())
      return true ;
  // recupero lo stile
   string sFont ;
   double dHStyle ;
   double dRatStyle ;
   GetStyleData( sStyle, sFont, dHStyle, dRatStyle) ;
   if ( abs( dH) < EPS_SMALL)
      dH = dHStyle ;
   if ( abs( dRat) < EPS_SMALL)
      dRat = dRatStyle ;
  // il punto di inserimento è sempre ETXT_IPBL
  // inserisco il testo nel DB geometrico
   // creo il testo
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   if ( IsNull( pTXT))
      return false ;
   // setto il testo
   if ( ! pTXT->Set( ptP, vtExtr, vtDir, sText, sFont, 400, false, dH, dRat, 0, ETXT_IPBL))  
      return false ;
  // inserisco il testo nel DB
   if ( nGroupId == GDB_ID_NULL)
      nGroupId = GetGroupId( sLayer) ;
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nGroupId, Release( pTXT)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::AdjustText( string& sText)
{
  // se non è testo UTF-8, tento di convertirlo secondo codepage dichiarata nel DXF
   if ( ! IsTextUtf8( sText.c_str())) {
      sText = LPSTR( WtoA( LPWSTR( AtoW( sText.c_str(), m_nCodePage)))) ;
   }

  // converto la codifica Unicode di AutoCad ( "\\U+NNNN")
   size_t nPos ;
   while ( ( nPos = sText.find( "\\U+")) != string::npos) {
      string sCode = (( sText.size() > nPos + 3) ? sText.substr( nPos+3, 4) : "") ;
      unsigned int nCode = 127 ;
      sscanf_s( sCode.c_str(), "%x", &nCode) ;
     // converto diametro in O maiuscolo barrato
      if ( nCode == 8709)
         nCode = 216 ;
      string sVal ;
      if ( ! SetCodePoint( nCode, sVal))
         sVal = "\7F" ;   // carattere di errore 127
      ReplaceString( sText, "\\U+" + sCode, sVal) ;
   }

  // trasformazione caratteri di controllo (per ora solo alcuni)
   ReplaceString( sText, "^I", " ") ;
   ReplaceString( sText, "^J", " ") ;
   ReplaceString( sText, "^ ", "^") ;

  // se non ci sono "%%" posso uscire
   if ( sText.find( "%%") == string::npos)
      return true ;

  // salvo codifica di singoli '%'
   ReplaceString( sText, "%%%", "§§") ;

  // elimino segnalazioni overscore e underscore
   ReplaceString( sText, "%%o", "") ;
   ReplaceString( sText, "%%O", "") ;
   ReplaceString( sText, "%%u", "") ;
   ReplaceString( sText, "%%U", "") ;

  // per gradi, più o meno e diametro
   ReplaceString( sText, "%%d", LPSTR( WtoA( L"°"))) ;
   ReplaceString( sText, "%%D", LPSTR( WtoA( L"°"))) ;
   ReplaceString( sText, "%%p", LPSTR( WtoA( L"±"))) ;
   ReplaceString( sText, "%%P", LPSTR( WtoA( L"±"))) ;
   ReplaceString( sText, "%%c", LPSTR( WtoA( L"Ø"))) ;
   ReplaceString( sText, "%%C", LPSTR( WtoA( L"Ø"))) ;

  // eventuali "%%" rimasti vanno eliminati
   ReplaceString( sText, "%%", "") ;
   
  // ripristino singoli '%'
   ReplaceString( sText, "§§", "%") ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadMText( bool& bFileEnd)
{
   Point3d  ptP ;
   Vector3d vtExtr = Z_AX ;
   Vector3d vtDirG = V_NULL ;
   string   sText ;
   string   sLayer ;
   string   sStyle = "STANDARD" ;
   double   dH ;
   double   dTextMaxWidth = 0 ;
   double   dAngRad = 0 ;
   int      nInsPos = ETXT_IPBL ;
   int      nSpace = ENT_MODELSPACE ;
   int      nColor = COL_BYLAYER ;
   int      nHide = ENT_SHOW ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   bool bEmbObj = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // se Embedded Obj da saltare
      if ( bEmbObj)
         continue ;
     // eventuale gestione
      switch ( nCode) {
      case 1 :
         sText += m_sCurrItem ;
         break ;
      case 3 :
         sText += m_sCurrItem ;
         break ;
      case 7 :
         sStyle = m_sCurrItem ;
         break ;
      case 8 :
         sLayer = m_sCurrItem ;
         break ;
      case 10 :
         FromString( m_sCurrItem, ptP.x) ;
         break ;
      case 20 :
         FromString( m_sCurrItem, ptP.y) ;
         break ;
      case 30 :
         FromString( m_sCurrItem, ptP.z) ;
         break ;
      case 11 :
         FromString( m_sCurrItem, vtDirG.x) ;
         break ;
      case 21 :
         FromString( m_sCurrItem, vtDirG.y) ;
         break ;
      case 31 :
         FromString( m_sCurrItem, vtDirG.z) ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dH) ;
         break ;
      case 41 :
         FromString( m_sCurrItem, dTextMaxWidth) ;
         break ;
      case 50 :
         FromString( m_sCurrItem, dAngRad) ;
         break ;
      case 60 :
         FromString( m_sCurrItem, nSpace) ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      case 67 :
         FromString( m_sCurrItem, nHide) ;
         break ;
      case 71 :
         FromString( m_sCurrItem, nInsPos) ;
         break ;
      case 210 :
         FromString( m_sCurrItem, vtExtr.x) ;
         break ;
      case 220 :
         FromString( m_sCurrItem, vtExtr.y) ;
         break ;
      case 230 :
         FromString( m_sCurrItem, vtExtr.z) ;
         break ;
      case 101 :
        // per saltare gli Embedded Objects di DXF 2018 (sembra siano solo negli MTEXT)
         bEmbObj = true ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // se entità in paperspace o nascosta, la salto
   if ( nSpace == ENT_PAPERSPACE  ||  nHide == ENT_HIDE)
      return true ;
  // eventuale aggiustamento del nome del layer per caratteri non ammessi
   ValidateVal( sLayer) ;
  // eventuale aggiustamento dello stile per caratteri non ammessi e trasformazione in maiuscolo
   ValidateVal( sStyle) ;
   ToUpper( sStyle) ;
  // aggiusto per il fattore di scala
   ptP *= m_dScaleFactor ;
   dH *= m_dScaleFactor ;
  // versore iniziale (da angolo)
   Vector3d vtDir = FromPolar( 1, dAngRad * RADTODEG) ;
  // gestisco eventuale OCS
   if ( ! AreSameVectorExact( vtExtr, Z_AX)) {
      Frame3d frOCS ;
      if ( ! frOCS.Set( ORIG, vtExtr))
         return false ;
     // il punto è già in globale
     // trasformo solo il versore iniziale dato come angolo
      vtDir.ToGlob( frOCS) ; 
   }
  // scelgo direzione 
   if ( vtDirG.IsSmall())
      vtDirG = vtDir ;
  // gestisco il riferimento del gruppo di inserimento
   if ( ! BlockReading()) {
      ptP.ToLoc( m_frGroup) ;
      vtExtr.ToLoc( m_frGroup) ;
      vtDirG.ToLoc( m_frGroup) ;
   }
  // recupero lo stile ( utilizzo font e aspect-ratio)
   string sFont ;
   double dHStyle ;
   double dRatStyle ;
   GetStyleData( sStyle, sFont, dHStyle, dRatStyle) ;
   if ( dRatStyle < EPS_SMALL)
      dRatStyle = 1 ;
  // aggiusto i caratteri
   AdjustMText( sText, dTextMaxWidth, dH * dRatStyle) ;
  // se testo è nullo, non lo inserisco ma proseguo senza errore
   if ( sText.empty())
      return true ;
  // inserisco il testo nel DB geometrico
   // creo il testo
   PtrOwner<IExtText> pTXT( CreateExtText()) ;
   if ( IsNull( pTXT))
      return false ;
   // setto il testo
   if ( ! pTXT->Set( ptP, vtExtr, vtDirG, sText, sFont, 400, false, dH, dRatStyle, 0, nInsPos))  
      return false ;
  // inserisco il testo nel DB
   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, GetGroupId( sLayer), Release( pTXT)) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // eventuale assegnazione del colore
   if ( ! SetColor( nId, nColor, sLayer))
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::AdjustMText( string& sText, double dTextMaxWidth, double dW)
{
  // sostituzioni valide anche per testi semplici
   if ( ! AdjustText( sText))
      return false ;

  // gestione "\\\\"
   ReplaceString( sText, "\\\\", "çç") ;
  // elimino \L  \k
   sText = regex_replace( sText, regex( "\\\\[LlOoKk]"), string( "")) ;
  // elimino \p...; \T...;
   sText = regex_replace( sText, regex( "\\\\[pQHWFfACT][^;]*;"), string( "")) ;
  // trasformo \Sxxx; in xxx
   sText = regex_replace( sText, regex( "\\\\[S]([^;]*);"), string( "$1")) ;
  // traformo "\~" in ' '
   ReplaceString( sText, "\\~", " ") ;
  // trasformo "\P" in "\n"
   ReplaceString( sText, "\\P", "\n") ;
  // cancello '{' e '}' trasformo "\{" in '{' e "\}" in'}' 
   ReplaceString( sText, "\\{", "§§") ;
   ReplaceString( sText, "{", "") ;
   ReplaceString( sText, "§§", "{") ;
   ReplaceString( sText, "\\}", "§§") ;
   ReplaceString( sText, "}", "") ;
   ReplaceString( sText, "§§", "}") ;
  // trasformo "\\" in '\'
   ReplaceString( sText, "çç", "\\") ;

  // se richiesto controllo lunghezza massima
   if ( dTextMaxWidth > EPS_SMALL) {
     // ATT : NON SONO GESTITI I CODICI UNICODE !!!
     // coefficiente empirico che in generale migliora l'adattamento
      const double COEFF_LARGH = 1.2 ;
     // gestione max lunghezza riga di testo
      size_t nLastSp = - 1 ;
      double dCurrWidth = 0 ;
      for ( size_t i = 0 ; i < sText.size() ; ++ i) {
        // posso dividere solo sugli spazi
         if ( sText[i] == ' ')
            nLastSp = i ;
        // se c'è già un a capo
         if ( sText[i] == '\n') {
            dCurrWidth = 0 ;
            nLastSp = - 1 ;
         }
        // se supera il limite
         else if ( dCurrWidth > COEFF_LARGH * dTextMaxWidth) {
           // se nella riga c'è già uno spazio
            if ( nLastSp != - 1) {
               sText.replace( nLastSp, 1, ETXT_LINEBREAK) ;
               dCurrWidth = ( i - nLastSp) * dW ;
               i += ETXT_LINEBREAK.size() - 1 ;
               nLastSp = - 1 ;
            }
         }
        // incremento la larghezza corrente
         else
           // larghezza con compensazione empirica
            if ( sText[i] == ' '  ||  sText[i] == '"')
               dCurrWidth += 0.6 * dW ;
            else if ( sText[i] == 'i'  ||  sText[i] == 'l'  ||  sText[i] == '!'  ||
                      sText[i] == '.'  ||  sText[i] == ','  ||  sText[i] == ':'  ||
                      sText[i] == ';'  ||  sText[i] == '\'')
               dCurrWidth += 0.3 * dW ;
            else
               dCurrWidth += dW ;
      }
   }

  // sostituzione finale di eventuali line break da utente
   ReplaceString( sText, "\n", ETXT_LINEBREAK) ;

   return true ;
}