//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : Import3MF.h           Data : 29.01.21          Versione : 2.3b1 
// Contenuto : Dichiarazione della classe Import3MF.
//
//
//
// Modifiche : 21.01.21 SP Creazione modulo.
//
//
//----------------------------------------------------------------------------


//--------------------------- Include ----------------------------------------

#include "stdafx.h"
#include "Import3MF.h"
#include "DllMain.h"
#include "pugixml.hpp"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Extern/libzip/Include/zip.h" 


using namespace std ;

//----------------------------------------------------------------------------
IImport3MF*
CreateImport3MF( void)
{
   // verifico la chiave e le opzioni
   if ( ! TestKeyForEEx( GetEExKey(), KEYOPT_EEX_INPBASE, GetEExLogger()))
      return nullptr ;
   // creo l'oggetto
   return static_cast<IImport3MF*> ( new( nothrow) Import3MF) ;
}

//----------------------------------------------------------------------------
bool
Import3MF::Import( const string& sFile, IGeomDB* pGDB, int nIdGroup)
{ 
    LOG_INFO( GetEExLogger(), ( "Import3MF : " + sFile).c_str()) ;

  // verifico il DB geometrico
   if ( pGDB == nullptr) {
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error on GeomDB") ;
      return false ;
   }
   m_pGDB = pGDB ;

  // verifico l'Id di gruppo
   if ( ! m_pGDB->ExistsObj( nIdGroup)) {
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error on IdGroup") ;
      return false ;
   }
   m_nIdGroup = nIdGroup ;

  // Apertura file 3MF
   int nErrorZip ;   
   m_ziparchive = zip_open( sFile.c_str(), ZIP_RDONLY, &nErrorZip) ;
   if ( m_ziparchive == nullptr){
      string sError = "  Import3MF : Error opening file. " ;      
      if ( nErrorZip == ZIP_ER_INVAL)
         sError += "Invalid path" ;
      else if ( nErrorZip == ZIP_ER_MEMORY)
         sError += "Required memory could not be allocated" ;
      else if ( nErrorZip == ZIP_ER_NOENT)
         sError += "Path does not exist" ;
      else if ( nErrorZip == ZIP_ER_NOZIP)
         sError += "File is not a zip archive" ;
      else if ( nErrorZip == ZIP_ER_OPEN)
         sError += "Path could not be opened" ;
      else if ( nErrorZip == ZIP_ER_READ)
         sError += "A read error occurred" ;
      LOG_ERROR( GetEExLogger() , sError.c_str()) ;
   }

  // Apertura del file con il modello 3D
   string sModelFileName = "3D/3dmodel.model" ; 
   struct zip_stat sb ;
   if ( zip_stat( m_ziparchive, sModelFileName.c_str(), 0, &sb) == -1){
     // se il nome del file non è standard lo cerco dal file .rels
      sModelFileName = FindFileName() ;
      if ( zip_stat( m_ziparchive, sModelFileName.c_str(), 0, &sb) == -1){
         LOG_ERROR( GetEExLogger(), "  Import3MF : file .model not found") ;
         return false ;  
      }   
   }

   zip_file_t * file = zip_fopen( m_ziparchive, sModelFileName.c_str(), ZIP_FL_UNCHANGED) ;
   if ( file == nullptr){
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error opening .model file") ;
      return false ;   
   }

   size_t filesize = ( size_t) sb.size ;
   char * contents = new char[filesize] ;
   if ( zip_fread( file, contents, sb.size) == -1){
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error reading .model file") ;
      return false ;
   }

  // Lettura file 
   pugi::xml_document doc ;
   pugi::xml_parse_result ParseResult = doc.load_buffer( contents, filesize) ;  // inizializzo il documento 
   if ( ! ParseResult) {
      string sError = "  Import3MF : Error parsing file. " ;
      sError += ParseResult.description() ;
      LOG_ERROR( GetEExLogger(), sError.c_str()) ;
      return false ;  
   }

   pugi::xml_node rootNode = doc.first_child() ;  
   std::string sUnit = rootNode.attribute( "unit").value() ;
   if ( sUnit == "micron")
      m_nScaleFactor = 0.001 ;
   else if ( sUnit == "centimeter")
      m_nScaleFactor = 10.0 ;
   else if ( sUnit == "meter")
      m_nScaleFactor = 1000.0 ;
   else if ( sUnit == "inch")
      m_nScaleFactor = 25.4 ;
   else if ( sUnit == "foot")
      m_nScaleFactor = 304.8 ;
   else 
      m_nScaleFactor = 1.0 ; // mm

  // Check sulle estensioni 
   string sExtensions = rootNode.attribute( "requiredextensions").value() ;
   if ( sExtensions.find( "b") != string::npos)
      LOG_ERROR( GetEExLogger(), "  Warning : Beam Lattice Extension is not supported") ;
   if ( sExtensions.find( "s") != string::npos)
      LOG_ERROR( GetEExLogger(), "  Warning : Slice Extension is not supported") ;
   if ( sExtensions.find( "enc") != string::npos)
      LOG_ERROR( GetEExLogger(), "  Warning : Secure Content Extension is not supported") ;

  // Analisi metadata
   for ( pugi::xml_node_iterator it = rootNode.first_child() ; it != rootNode.end() ; it++){
      string sName = it->name() ;
      if ( sName == "metadata"){
         string sValue = it->text().get() ;
         m_pGDB->SetInfo( m_nIdGroup, it->attribute( "name").value(), sValue) ;         
      }   
   }

  // Resource node
   pugi::xml_node baseResources = rootNode.child( "resources") ;
   if ( baseResources == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF model : no resources node") ;
      return false ;
   }
   if ( baseResources.child( "m:texture2d") != nullptr || baseResources.child( "m:texture2dgroup") != nullptr)
      LOG_ERROR( GetEExLogger(), "  Warning : textures are ignored") ;
   if ( baseResources.child( "m:pbspeculardisplayproperties") != nullptr || baseResources.child( "m:pbmetallicdisplayproperties") != nullptr
      || baseResources.child( "m:pbspeculartexturedisplayproperties") != nullptr || baseResources.child( "m:pbmetallictexturedisplayproperties") != nullptr
      || baseResources.child( "m:translucentdisplayproperties") != nullptr)
      LOG_ERROR( GetEExLogger(), "  Warning : display properties are ignored") ;

  // Build node
   bool bReadOk ; 
   pugi::xml_node build_node =  rootNode.child( "build") ; 
   if ( build_node == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF model : no build node") ;
      return false ;
   }  
  // Attributes
   for ( pugi::xml_attribute attr = build_node.first_attribute() ; attr ; attr = attr.next_attribute()){
      if ( ! attr)  
         break ;
      string sValue = attr.value() ;
      m_pGDB->SetInfo( m_nIdGroup, attr.name(), sValue) ;   
   }
  // Scorro tutti gli items 
   for ( pugi::xml_node_iterator itBuild = build_node.first_child() ; itBuild != build_node.end() ; itBuild ++){
      std::string sName = itBuild->name() ;
      if ( sName == "item"){
         bReadOk = ReadItem( *itBuild, baseResources) ;
         if ( ! bReadOk)
            return false ;
      }
   }

   return true ;   
}

//---------------------------------------------------------------------------------------
string 
Import3MF::FindFileName()
{ 
   struct zip_stat sb ;
   if ( zip_stat( m_ziparchive, "_rels/.rels", 0, &sb) == -1){
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error opening .rels file") ;
      return " " ;
   }

   zip_file_t * file = zip_fopen( m_ziparchive, "_rels/.rels", ZIP_FL_UNCHANGED) ; 
   if ( file == nullptr){
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error opening .rels file") ;
      return " " ;     
   }

   size_t filesize = ( size_t) sb.size ;
   char * contents = new char[ filesize] ;   
   if ( zip_fread( file, contents, sb.size) == -1){
      LOG_ERROR( GetEExLogger(), "  Import3MF : Error reading .rels file") ;
      return " " ;
   }

  // Lettura file 
   pugi::xml_document doc ;   
   pugi::xml_parse_result ParseResult = doc.load_buffer( contents, filesize) ;

   if ( ! ParseResult) {
      string sError = "  Import3MF : Error parsing file. " ;
      sError += ParseResult.description() ;
      LOG_ERROR( GetEExLogger(), sError.c_str()) ;
      return " " ;  
   }

   pugi::xml_node root = doc.first_child() ;
   for ( pugi::xml_node_iterator it = root.first_child() ; it != root.end() ; it ++ ){
      string sNodeName = it->name() ;
      if ( sNodeName == "Relationship"){
         if ( it->attribute( "Target") != nullptr){
            string sTarget = it->attribute( "Target").value() ;
            if ( sTarget.substr( 0, 11) != "/Thumbnails")
               return sTarget.erase( 0, 1) ;   // elimino il "/" iniziale nel nome del file            
         }     
      }  
   }

   return " " ;
}

//----------------------------------------------------------------------------------------------------
bool 
Import3MF::ReadItem( pugi::xml_node node, pugi::xml_node resources)
{
   int id = node.attribute( "objectid").as_int() ;

  // Trasformazione
   DBLVECTOR vTransform ;
   if ( node.attribute( "transform") != nullptr){     
      string sTransform = node.attribute( "transform").value() ;
      vTransform = ReadTransform( sTransform, m_nScaleFactor) ; 
      if ( vTransform.empty())
         return false ;
   } 

  // Attributes
   ATTRVECTOR attrItem ;
   for ( pugi::xml_attribute attr = node.first_attribute() ; attr ; attr = attr.next_attribute()){
      string sAttrName = attr.name() ;
      string sAttrVal = attr.value() ;
      if ( sAttrName != "" && sAttrVal != "" && sAttrName != "objectid" && sAttrName != "transform" && sAttrName != "p:path")
         attrItem.push_back( make_pair( "Item " + sAttrName, sAttrVal)) ;
   }
   if ( node.child( "metadatagroup") != nullptr){
      bool bReadOk = ReadMetadataGroup( node.child( "metadatagroup"), attrItem, ITEM) ;
      if ( ! bReadOk)
         return false ;      
   }   

   if ( node.attribute( "p:path") == nullptr ){                // elemento nello stesso file
      bool bReadOk = ReadObject( resources, id, attrItem, vTransform, m_nScaleFactor) ;
      if ( ! bReadOk)
         return false ;    
   }
   else {                                                     // elemento in un altro file
      string sFileName = node.attribute( "p:path").value() ;
      bool bReadOk = ReadFromFile( sFileName, id, attrItem, vTransform) ;
      if ( ! bReadOk)
         return false ;      
   }     

   return true ;
}

//-------------------------------------------------------------------------------------------------
bool
Import3MF::ReadObject( pugi::xml_node resources, int& id, ATTRVECTOR& attributes, DBLVECTOR& transform, double& nScaleFactor){ 

   bool bFound = false ;
   pugi::xml_node node ;
  // Cerco nodo fra i children del nodo resources
   for ( pugi::xml_node_iterator it = resources.begin() ; it != resources.end() && ! bFound ; it++){
      if ( *it == nullptr)
         return false ;
      int nResId = it->attribute( "id").as_int() ; 
      if ( nResId == id){
         node = *it ;  
         bFound = true ;
      }
   }   
   if ( ! bFound){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF model : Object not found") ;
      return false ;
   }

  // bool per capire se object contiene mesh  
   bool bObjMesh = false ;  
   if ( node.child( "mesh") != nullptr)
      bObjMesh = true ;

  // Attributes   
   int pid = -1 ;
   int pindex = -1 ;
   if ( node.attribute( "pid") != nullptr)
      pid = node.attribute( "pid").as_int() ;      
   if ( node.attribute( "pindex") != nullptr)
      pindex = node.attribute( "pindex").as_int() ;
  // Attributes generici
   for ( pugi::xml_attribute attr = node.first_attribute() ; attr ; attr = attr.next_attribute()){
      string sAttrName = attr.name() ;
      string sAttrVal = attr.value() ;
      if ( sAttrName != "" && sAttrName != "pid" && sAttrName != "pindex" && sAttrName != "id" && sAttrVal != "" )
         if ( bObjMesh)
            attributes.push_back( make_pair( sAttrName, sAttrVal)) ;
         else
            attributes.push_back( make_pair( "Object " + sAttrName, sAttrVal)) ;
   }

  // Sottonodi 
   bool bReadOk = true ;
   for ( pugi::xml_node_iterator itObj = node.first_child() ; itObj != node.end() ; itObj ++){
      std::string sName = itObj->name() ;
      if ( sName == "metadatagroup")
         bReadOk = ReadMetadataGroup( *itObj, attributes, ( bObjMesh ? MESH : COMPONENT)) ;
      else if ( sName == "mesh")
         bReadOk = ReadMesh( *itObj, resources, pid, pindex, attributes, transform, nScaleFactor) ;             
      else if ( sName == "components")
         bReadOk = ReadComponents( *itObj, resources, attributes, transform, nScaleFactor) ;

      if ( ! bReadOk)
         return false ;
   }

   return true ;

}

//----------------------------------------------------------------------------------------------------------------
bool 
Import3MF::ReadMesh( pugi::xml_node node, pugi::xml_node resources, int& pid, int& pindex, ATTRVECTOR& attributes, DBLVECTOR& transform, 
                     double& nScaleFactor)
{  
   StmFromTriangleSoup Stm ;
   bool bStmOk = Stm.Start() ;
   if ( ! bStmOk) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : stm.start error") ;
      return false ;
   }

  // Vettore vertici
   std::vector< Point3d> vVertices ;
   pugi::xml_node vertNode = node.child( "vertices") ;
   if ( vertNode == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : no vertices") ;
      return false ;
   }

   for ( pugi::xml_node_iterator itVert = vertNode.first_child() ; itVert != vertNode.end() ; itVert ++ ){
      std::string sName = itVert->name() ;
      if ( sName == "vertex"){
         Point3d pt ;
        // Controllo ci siano tutti gli attributes richiesti
         if ( itVert->attribute( "x") == nullptr || itVert->attribute( "y") == nullptr || itVert->attribute( "z") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : missing vertex coordinate") ;
            return false;
         } 
        // Applico eventuale trasformazione alle coordinate
         if ( ! transform.empty()) {
            DBLVECTOR x { itVert->attribute( "x").as_double(), itVert->attribute( "y").as_double(), 
               itVert->attribute( "z").as_double(), 1} ;
            DBLVECTOR res( 3, 0.0) ;
            x[0] *= nScaleFactor ;
            x[1] *= nScaleFactor ;
            x[2] *= nScaleFactor ;
            for ( size_t i = 0 ; i < 3 ; i++) {
               for ( size_t j = 0 ; j < 4 ; j++)
                  res[i] += x[j]*transform[4*j+i] ;         
            }

            pt.Set( res[0], res[1], res[2]) ;                  
         }
         else {
            pt.Set( itVert->attribute( "x").as_double(), itVert->attribute( "y").as_double(), itVert->attribute( "z").as_double()) ;
            pt *= nScaleFactor ;
         }

          vVertices.push_back( pt) ;
      }   
   }

  // Lettura triangoli
   pugi::xml_node trgNode = node.child( "triangles") ;    
   if ( trgNode == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : missing triangles") ;
      return false ;
   }
   for ( pugi::xml_node_iterator itTrg = trgNode.first_child() ; itTrg != trgNode.end() ; itTrg ++){
      if ( *itTrg == nullptr){
         LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : missing triangles") ;
         return false ;       
      }

      std::string sName = itTrg->name() ;
      if ( sName == "triangle"){
         if ( itTrg->attribute( "v1") == nullptr || itTrg->attribute( "v2") == nullptr || itTrg->attribute( "v3") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : missing triangle vertex") ;
            return false ;
         }
         int v1 = itTrg->attribute( "v1").as_int() ;
         int v2 = itTrg->attribute( "v2").as_int() ;
         int v3 = itTrg->attribute( "v3").as_int() ;

         bool bTAddOk = Stm.AddTriangle( vVertices[v1], vVertices[v2], vVertices[v3]) ;
         if ( ! bTAddOk) {
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : stm.AddTriangle error") ;
            return false ;
         }        
      }
   }
   bStmOk = Stm.End() ;
   if ( ! bStmOk) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : stm.end error") ;
      return false ;
   }

   ISurfTriMesh* pSurf = Stm.GetSurf() ;
   if ( pSurf == nullptr) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : stm.GetSurf error") ;
      return false ;
   }

   int nId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nIdGroup, pSurf) ; 
   if ( nId == GDB_ID_NULL) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : GDB.AddGeoOjb error") ;
      return false ;
   }

  // Colore
   if ( pid != -1 && pindex != -1) {
      Color col = FindColor( resources, pid, pindex) ;
      if ( ! ( col == Color( 0, 0, 0, 0)))
         m_pGDB->SetMaterial( nId, col) ;
   }

  // Attributes
   for ( size_t i = 0 ; i < attributes.size() ; i++){
      if ( attributes[i].first == "name")
         m_pGDB->SetName( nId, attributes[i].second) ;
      else
         m_pGDB->SetInfo( nId, attributes[i].first, attributes[i].second) ;    
   }

   return true ;
}

//-----------------------------------------------------------------------------------
bool 
Import3MF::ReadComponents( pugi::xml_node node, pugi::xml_node resources, ATTRVECTOR attributes, DBLVECTOR vItemTransform, double& nScaleFactor)
{
  // Scorro tutte le componenti
   for ( pugi::xml_node_iterator it = node.first_child() ; it != node.end() ; it++){
      string sName = it->name() ;
      if ( sName == "component"){
         int id = it->attribute( "objectid").as_int() ;

        // Attributes
         for ( pugi::xml_attribute attr = it->first_attribute() ; attr ; attr = attr.next_attribute()){
            string sAttrName = attr.name() ;
            string sAttrVal = attr.value() ;
            if ( sAttrName != "" && sAttrName != "transform" && sAttrName != "p:path" && sAttrName != "objectid" && sAttrVal != "") {               
               attributes.push_back( make_pair( "Component " + sAttrName, sAttrVal)) ;  
            }
         }

        // Trasformazioni
         bool bCompTransf = false ; 
         DBLVECTOR vCompTransform ;
         DBLVECTOR vResTransform( 16, 0.0) ;
         if ( it->attribute( "transform") != nullptr){
            bCompTransf = true ;
            string sTransform = it->attribute( "transform").value() ;
            vCompTransform = ReadTransform( sTransform, nScaleFactor) ;  
            if ( vCompTransform.empty()) 
               return false ;
         }

         if ( ! vItemTransform.empty() && bCompTransf ){
           // Combino le trasformazioni dell'item e del component 
            for ( size_t i = 0 ; i < 4 ; i++) 
               for ( size_t j = 0 ; j < 4 ; j++)
                  for ( size_t k = 0 ; k < 4 ; k++)
                     vResTransform[4*i+j] += vCompTransform[4*i+k]*vItemTransform[4*k+j] ;          
         }
         else if ( bCompTransf)   // Ho solo la trasformazione della component         
            vResTransform = vCompTransform ;
         else                     // Ho solo la trasformazione dell'item 
            vResTransform = vItemTransform ;

         if ( it->attribute( "p:path") == nullptr){            
            bool bReadOk = ReadObject( resources, id, attributes, vResTransform, nScaleFactor) ;
            if ( ! bReadOk)
               return false ;    
         }
        // elemento si trova in un altro file
         else {           
            string sFileName = it->attribute( "p:path").value() ; 
            bool bReadOk = ReadFromFile( sFileName, id, attributes, vResTransform) ;
            if ( ! bReadOk)
               return false ; 
         }             
      }   
   }

   return true ;
}


//---------------------------------------------------------------------
DBLVECTOR 
Import3MF::ReadTransform( string& sTransform, double& nScaleFactor)
{
   DBLVECTOR vTransform ;
  // aggiungo uno spazio alla fine della stringa per gestire correttamente anche l'ultimo valore con il while
   sTransform.push_back( ' ') ;
   size_t str_start = 0 ;
   size_t str_end ;
   while( ( str_end = sTransform.find( " ", str_start)) != std::string::npos ){
      string sval = sTransform.substr( str_start, str_end - str_start) ;
      if ( ! sval.empty())   // check per evitare il caso di due spazi consecutivi
         vTransform.push_back( std::stod( sval)) ;
      str_start = str_end + 1 ;             
   } 

   if ( vTransform.size() != 12){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF Transform : missing transformation component") ;
      vTransform.clear() ;
      return vTransform ;
   }

  // Aggiungo ultima colonna per renderla matrice 4x4 
   vTransform.insert( vTransform.begin() + 3, 0.0 ) ;
   vTransform.insert( vTransform.begin() + 7, 0.0 ) ;
   vTransform.insert( vTransform.begin() + 11, 0.0 ) ;
   vTransform.push_back( 1.0) ;

  // Scale factor 
   vTransform[12] *= nScaleFactor ;
   vTransform[13] *= nScaleFactor ;
   vTransform[14] *= nScaleFactor ;

   return vTransform ;
}


//------------------------------------------------------------------------------------
Color 
Import3MF::FindColor( pugi::xml_node resources, int pid, int pindex)
{
  // Cerco la resources con quell'id   
   pugi::xml_node node ;
   bool bFound = false ;
   for ( pugi::xml_node_iterator it = resources.begin() ; it != resources.end() && ! bFound ; it++){
      int nResId = it->attribute( "id").as_int() ; 
      if ( nResId == pid){
         node = *it ;  
         bFound = true ;
      }
   }
   if ( ! bFound){
      LOG_ERROR( GetEExLogger(),  "  Error reading 3MF : object not found") ;
      return false ;  
   }

   std::string sName = node.name() ;
  // contatore per pindex
   int count = -1 ;   

  if ( sName == "m:colorgroup" || sName == "r:colorgroup"){  
      for ( pugi::xml_node_iterator itColor = node.first_child() ; itColor != node.end() ; itColor ++){
         std::string sColName = itColor->name() ;        
         if ( sColName == "m:color" || sColName == "r:color")
            count ++ ; 
         if ( count == pindex){
            std::string sCol = itColor->attribute( "color").value() ;
            return ColorConverter( sCol) ;                
         }     
      }        
   }
   else if ( sName == "basematerials"){   
      for ( pugi::xml_node_iterator itBase = node.first_child() ; itBase != node.end() ; itBase ++){
         std::string sBaseName = itBase->name() ;        
         if ( sBaseName == "base")
            count ++ ; 
         if ( count == pindex){
            std::string sCol = itBase->attribute( "displaycolor").value() ;
            return ColorConverter( sCol) ;                
         }
      }        
   }
   else if ( sName == "m:multiproperties")
      return ReadMultiPropertiesColor( node, resources, pid, pindex) ;   
   else if ( sName == "m:compositematerials")
      return ReadCompositeMaterialColor( node, resources, pid, pindex) ;

   return Color( 0, 0, 0, 0) ;    // colore trasparente 
}

//--------------------------------------------------------------------------------------
Color
Import3MF::ReadCompositeMaterialColor( pugi::xml_node node, pugi::xml_node resources, int pid, int pindex)
{  
   if ( node.attribute( "matid") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF : CompositeMaterial has no BaseMaterial") ;
      return Color( 0, 0, 0, 0) ;        
   }
   int nBaseMatId = node.attribute( "matid").as_int() ;

  // matindices -> da stringa vanno messi in vettore di interi
   string sMatIndices = node.attribute( "matindices").value() ;
   sMatIndices.push_back( ' ') ;
   vector<int> vMatIndices ;
   size_t str_start = 0 ;
   size_t str_end ;
   while( ( str_end = sMatIndices.find( " ", str_start)) != std::string::npos ){
      string sval = sMatIndices.substr( str_start, str_end - str_start) ;
      if ( ! sval.empty())  
         vMatIndices.push_back( std::stoi( sval)) ;
      str_start = str_end + 1 ;              
   }

   int count = -1 ;
   string sCompValues ;
   for ( pugi::xml_node_iterator it = node.first_child() ; it != node.end() ; it++){
      string sNodeName = it->name() ;
      if ( sNodeName == "m:composite")
         count ++ ;
      if ( count == pindex){
         if ( it->attribute( "values") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF : CompositeMaterial has no BaseMaterial") ;
            return Color( 0, 0, 0, 0) ; 
         }
         sCompValues = it->attribute( "values").value() ;
      }   
   }
   if ( sCompValues.empty()){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF : CompositeMaterial has no BaseMaterial") ;
      return Color( 0, 0, 0, 0) ; 
   }

  // sCompValues -> da stringa a vettore
   vector<double> vCompValues ;
   sCompValues.push_back( ' ') ;
   str_start = 0 ;
   while( ( str_end = sCompValues.find( " ", str_start)) != std::string::npos ){
      string sval = sCompValues.substr( str_start, str_end - str_start) ;
      if ( ! sval.empty())   
         vCompValues.push_back( std::stoi( sval)) ;
      str_start = str_end + 1 ;              
   }

  // check sui valori di vCompValues
   vCompValues.resize( vMatIndices.size(), 0.0) ;  
   double sum = 0.0 ;
   for ( size_t i = 0 ; i < vCompValues.size() ; i++)
      sum += vCompValues[i] ;
   if ( abs( sum - 1.0) < EPS_SMALL)
      for ( size_t i = 0 ; i < vCompValues.size() ; i++)
         vCompValues[i] /= sum ;
   if ( abs( sum) < EPS_SMALL)
      vCompValues.resize( vMatIndices.size(), 1.0) ;    

   vector<double> col(3, 0.0) ;
   Color BaseMatColor ;
   for ( size_t i = 0 ; i < vMatIndices.size() ; i++){
      BaseMatColor = FindColor( resources, nBaseMatId, vMatIndices[i]) ;
      if ( BaseMatColor == Color( 0, 0, 0, 0))
         return BaseMatColor ;
      col[0] += vCompValues[i] * BaseMatColor.GetRed() ;
      col[1] += vCompValues[i] * BaseMatColor.GetGreen() ;
      col[2] += vCompValues[i] * BaseMatColor.GetBlue() ; 
   }

   return Color( col[0], col[1], col[2]) ;
}

//--------------------------------------------------------------------------------------
Color
Import3MF::ReadMultiPropertiesColor( pugi::xml_node node, pugi::xml_node resources, int pid, int pindex)
{  

   if ( node.attribute( "pids") == nullptr){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF : MultiProperties has no pids") ;
      return Color( 0, 0, 0, 0) ;   
   }
  // pids -> da stringa vanno messi in vettore di interi
   string spids = node.attribute( "pids").value() ;
   spids.push_back( ' ') ;
   vector<int> vpids ;
   size_t str_start = 0 ;
   size_t str_end ;
   while( ( str_end = spids.find( " ", str_start)) != std::string::npos ){
      string sval = spids.substr( str_start, str_end - str_start) ;
      if ( ! sval.empty())  
         vpids.push_back( std::stoi( sval)) ;   
      str_start = str_end + 1 ;              
   }

   int new_id = -1 ;       // id elemento di MultiProperties che contiene un colore
   size_t new_pos = -1 ;   // posizione nel vettore pids associata a new_id
   int count = -1 ;        // contatore per pindices

  // Scorro il vettore di pids
   for ( size_t j = 0 ; j < vpids.size() ; j++){       
      bool bFound = false ;
      pugi::xml_node colorNode ;
     // Cerco resource con id corrispondente al pids considerato
      for ( pugi::xml_node_iterator it = resources.begin() ; it != resources.end() && ! bFound ; it++){
         int nResId = it->attribute( "id").as_int() ; 
         if ( nResId == vpids[j]){
            colorNode = *it ;  
            bFound = true ;
         }
      }
     // se non trovi resource con quell'id passo al pids successivo
      if ( ! bFound)      
         continue ;

      std::string colorNodeName = colorNode.name() ;
      if ( colorNodeName == "basematerial" || colorNodeName == "m:colorgroup" || colorNodeName == "r:colorgroup"){
         new_id = vpids[j] ;
         new_pos = j ;
         break ; 
      }         
   }

  // se quando ho finito i pids non ho trovato un elemento che potrebbe contenere un colore
   if ( new_id == -1){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : no object defining color") ;
      return Color( 0, 0, 0, 0) ;
   } 

  // altrimenti cerco l'elemento multi del multiproperties corrispondente al pindex
   for ( pugi::xml_node_iterator itMP = node.first_child() ; itMP != node.end() ; itMP ++){       
         std::string sMPName = itMP->name() ;        
      if ( sMPName == "m:multi") 
         count ++ ; 
      if ( count == pindex){
         if ( itMP->attribute( "pindices") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF : MultiProperties pindices missing") ;
            return Color( 0, 0, 0, 0) ;         
         }
         string spindices = itMP->attribute( "pindices").value() ;
         spindices.push_back( ' ') ;
         int new_index = -1 ;
        // Estraggo dalla stringa il valore in posizione new_pos
         int count2 = -1 ;          
         str_start = 0 ;                
         while( ( str_end = spindices.find( " ", str_start)) != std::string::npos ){
            count2 ++ ;           
            if ( count2 == new_pos){
               string sval = spindices.substr( str_start, str_end - str_start) ;
               if ( ! sval.empty())   
                  new_index = std::stoi( sval) ;               
               else 
                  new_index = 0 ;
               break ;
            }
            str_start = str_end + 1 ;
         }

         if ( new_index == -1)
            new_index = 0 ;
         return FindColor( resources, new_id, new_index) ;
      }
   }

   return Color( 0, 0, 0, 0) ;
}

//---------------------------------------------------------------------------------------
Color 
Import3MF::ColorConverter( std::string s)
{
   Color col ;
   vector<int> vCol ;

   if ( s.length() != 9 && s.length() != 7){
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF Color : undefined color") ;  
      return Color( 0, 0, 0, 0) ;
   }

   int pos = 1 ;
   while ( pos != s.length()){
      std::string substr = s.substr( pos, 2) ;
      vCol.push_back( strtol( substr.c_str(), NULL, 16)) ;  
      pos +=2 ;
   }

  // alpha
   if ( vCol.size() == 4)   
      vCol[3] *= 100 / 255 ;    
   else if ( vCol.size() == 3)
      vCol.push_back( 100) ;   

   if ( vCol[3] == 0)
      vCol[3] = 100 ;  // il colore è sempre assunto come completamente opaco

   return Color( &vCol[0]) ;
} 


//---------------------------------------------------------------------------------------
bool 
Import3MF::ReadFromFile( string sFileName, int id, ATTRVECTOR& attributes, DBLVECTOR& vTransform)
{
  // E' necessario togliere "/" dal nome del file
   sFileName.erase( 0, 1) ;    

  // Se documento non è mai stato letto prima
   if ( m_AuxDocuments.find( sFileName) == m_AuxDocuments.end()){    
  
      auto res = m_AuxDocuments.emplace( sFileName, pugi::xml_document()) ;
      if ( ! res.second)
         return false ;
   
      struct zip_stat sb ;
      if ( zip_stat( m_ziparchive, sFileName.c_str(), 0, &sb) == -1){
         LOG_ERROR( GetEExLogger(), "  Import3MF : Error opening auxiliary .model file ") ;
         return false ;         
      }
      zip_file_t * file = zip_fopen( m_ziparchive, sFileName.c_str(), ZIP_FL_UNCHANGED) ;
      size_t filesize = ( size_t) sb.size ;
      char * contents = new char[filesize] ;
      if ( zip_fread( file, contents, sb.size) == -1){
         LOG_ERROR( GetEExLogger(), "  Import3MF : Error reading auxiliary .model file") ;
         return false ;
      }
   
     // Lettura file      
      pugi::xml_parse_result ParseResult = m_AuxDocuments[ sFileName].load_buffer( contents, filesize) ;  // inizializzo il documento 
      if ( ! ParseResult) {
         string sError = "  Import3MF : Error parsing file : " ;
         sError += ParseResult.description() ;
         LOG_ERROR( GetEExLogger(), sError.c_str()) ;
         return false ;  
      }
   }
  
  // Lettura del documento
   pugi::xml_node auxrootNode = m_AuxDocuments[ sFileName].first_child() ;  // node model
   std::string sUnit = auxrootNode.attribute( "unit").value() ;
   double nScaleFactor ;
   if ( sUnit == "micron")
      nScaleFactor = 0.001 ;
   else if ( sUnit == "centimeter")
      nScaleFactor = 10.0 ;
   else if ( sUnit == "meter")
      nScaleFactor = 1000.0 ;
   else if ( sUnit == "inch")
      nScaleFactor = 25.4 ;
   else if ( sUnit == "foot")
      nScaleFactor = 304.8 ;
   else 
      nScaleFactor = 1.0 ; // mm

  // Cerco nodo resources
   pugi::xml_node auxResources = auxrootNode.child( "resources") ;
   if ( auxResources == nullptr){
      LOG_ERROR( GetEExLogger(), "    Error reading 3MF model : no resources node found ") ;
      return false ;
   }

   bool bReadOk = ReadObject( auxResources, id, attributes, vTransform, nScaleFactor) ; 
   if ( ! bReadOk)
      return false ;   

return true ;
}


//----------------------------------------------------------------------------------------------------
bool 
Import3MF::ReadMetadataGroup( pugi::xml_node node, ATTRVECTOR& v, MDGCaller caller)
{
   for ( pugi::xml_node_iterator it = node.begin() ; it != node.end() ; it++){
      string sNodeName = it->name() ;
      if ( sNodeName == "metadata"){
         if ( it->attribute( "name") == nullptr){
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF model : metadata name missing") ;
            return false ;         
         }

         string sName ;
         switch ( caller){
         case ITEM :
            sName = "Item " ;
            break ;
         case COMPONENT :
            sName = "Object " ;
            break ;
         }         
         sName += it->attribute( "name").value() ;
         string sValue = it->text().get() ;
         v.push_back( make_pair( sName, sValue)) ;
      }    
   }

   return true ;
}