Egalware/EgtExchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

EgtExchange 2.6l3 :

Browse Source 
- in import ed export 3MF gestione della gerarchia dei gruppi
- migliorie e correzioni varie.
This commit is contained in:
SaraP
2024-12-16 10:52:28 +01:00
parent 7778cf5027
commit aa80fb63af
5 changed files with 219 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files
EgtExchange.rc
BIN
View File
Binary file not shown.
Export3MF.cpp
+86 -88
View File
@@ -17,13 +17,9 @@
#include "Export3MF.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
#include "/EgtDev/Include/EGkGdbIterator.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
using namespace std ;
using namespace Lib3MF ;
@@ -69,13 +65,13 @@ Export3MF::Export( IGeomDB* pGDB, int nId, const string& sFile)
// libreria 3MF
m_wrapper = CWrapper::loadLibrary() ;
if ( ! m_wrapper) {
if ( m_wrapper == nullptr) {
LOG_ERROR( GetEExLogger(), "Export3MF : Error on lib3mf Wrapper")
return false ;
}
// creo model per 3MF
m_model = m_wrapper->CreateModel() ;
if ( ! m_model) {
if ( m_model == nullptr) {
LOG_ERROR( GetEExLogger(), "Export3MF : Error on lib3mf Model")
return false ;
}
@@ -90,20 +86,10 @@ Export3MF::Export( IGeomDB* pGDB, int nId, const string& sFile)
return false ;
pIter->GoTo( nId) ;
// assegno le info dell'oggetto al modello
PMetaDataGroup metaDataGrp = m_model->GetMetaDataGroup() ;
STRVECTOR vInfo ;
pIter->GetAllInfo( vInfo) ;
for ( const string& sInfo : vInfo) {
string sKey, sVal ;
SplitFirst( sInfo, "=", sKey, sVal) ;
metaDataGrp->AddMetaData( sInfoNamespace, sKey, sVal, "xs:string", 0) ;
}
// esporto l'oggetto e i suoi eventuali figli
if ( ! ExportObject( *pIter))
return false ;
// scrivo il file
try {
PWriter writer = m_model->QueryWriter( "3mf") ;
@@ -121,7 +107,7 @@ Export3MF::Export( IGeomDB* pGDB, int nId, const string& sFile)
//----------------------------------------------------------------------------
bool
Export3MF::ExportObject( const IGdbIterator& iIter)
Export3MF::ExportObject( const IGdbIterator& iIter, PComponentsObject pParent, bool bSaveGrpAsComponent)
{
// recupero il livello dell'oggetto
int nLev = GDB_LV_USER ;
@@ -135,48 +121,43 @@ Export3MF::ExportObject( const IGdbIterator& iIter)
int nType = iIter.GetGdbType() ;
// se il filtro lo abilita
if ( TestFilter( nLev, nMode, nStat, nType == GDB_TY_GROUP)) {
switch ( iIter.GetGdbType()) {
// se è un oggetto geometrico diverso da una superficie esco
int nGeoType = iIter.GetGeoType() ;
if ( nGeoType != GEO_NONE && nGeoType != SRF_TRIMESH && nGeoType != SRF_FLATRGN)
return true ;
// recupero nome
string sName ;
iIter.GetName( sName) ;
// recupero info
STRVECTOR vsInfo ;
iIter.GetAllInfo( vsInfo) ;
// esporto
switch ( nType) {
case GDB_TY_GEO :
{
// recupero l'oggetto geometrico
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
if ( pGeoObj == nullptr)
return true ;
// se non è una superficie esco
if ( pGeoObj->GetType() != SRF_TRIMESH && pGeoObj->GetType() != SRF_FLATRGN)
return true ;
return false ;
// recupero il riferimento globale dell'oggetto
Frame3d frFrame ;
if ( ! iIter.GetGlobFrame( frFrame))
return false ;
// recupero eventuale nome
string sName ;
if ( ! iIter.GetName( sName))
sName = ToString( iIter.GetId()) ;
return false ;
// recupero il colore
Color cCol ;
bool bCol = GetColor( cCol, iIter.GetGDB(), iIter.GetId()) ;
// recupero le proprietà
STRVECTOR vInfo ;
iIter.GetAllInfo( vInfo) ;
iIter.GetCalcMaterial( cCol) ;
// emetto l'oggetto
switch ( pGeoObj->GetType()) {
switch ( nGeoType) {
case SRF_TRIMESH :
if ( ! ExportSTM( sName, pGeoObj, frFrame, bCol ? &cCol : nullptr, vInfo))
return false ;
break ;
return ExportSTM( pGeoObj, frFrame, sName, vsInfo, cCol, pParent) ;
case SRF_FLATRGN :
if ( ! ExportSFR( sName, pGeoObj, frFrame, bCol ? &cCol : nullptr, vInfo))
return false ;
break ;
return ExportSFR( pGeoObj, frFrame, sName, vsInfo, cCol, pParent) ;
default :
break ;
return false ;
}
}
return true ;
case GDB_TY_GROUP :
// esploro il gruppo
return ScanGroup( iIter) ;
case GDB_TY_GROUP :
return ExportGroup( iIter, sName, vsInfo, pParent, bSaveGrpAsComponent) ;
default :
return false ;
}
@@ -186,7 +167,7 @@ Export3MF::ExportObject( const IGdbIterator& iIter)
//----------------------------------------------------------------------------
bool
Export3MF::TestFilter( int nLev, int nMode, int nStat, bool bGroup)
Export3MF::TestFilter( int nLev, int nMode, int nStat, bool bGroup) const
{
int nFilter = bGroup ? m_nGroupFilter : m_nFilter ;
if ( ( nLev == GDB_LV_USER && ( nFilter & EEXFLT_LEVUSER) == 0) ||
@@ -237,7 +218,8 @@ Export3MF::CalcGroupFilter( void)
//----------------------------------------------------------------------------
bool
Export3MF::ExportSFR( const string& sName, const IGeoObj* pGeoObj, const Frame3d& frFrame, const Color* pCol, const STRVECTOR& vInfo)
Export3MF::ExportSFR( const IGeoObj* pGeoObj, const Frame3d& frFrame, const string& sName, const STRVECTOR& vInfo,
const Color& cCol, PComponentsObject pParent)
{
// verifico oggetto
const ISurfFlatRegion* pSFR = GetSurfFlatRegion( pGeoObj) ;
@@ -245,12 +227,13 @@ Export3MF::ExportSFR( const string& sName, const IGeoObj* pGeoObj, const Frame3d
return false ;
// ricavo la trimesh equivalente
const ISurfTriMesh* pStm = pSFR->GetAuxSurf() ;
return ExportSTM( sName, pStm, frFrame, pCol, vInfo) ;
return ExportSTM( pStm, frFrame, sName, vInfo, cCol, pParent) ;
}
//----------------------------------------------------------------------------
bool
Export3MF::ExportSTM( const string& sName, const IGeoObj* pGeoObj, const Frame3d& frFrame, const Color* pCol, const STRVECTOR& vInfo)
Export3MF::ExportSTM( const IGeoObj* pGeoObj, const Frame3d& frFrame, const string& sName, const STRVECTOR& vInfo,
const Color& cCol, PComponentsObject pParent)
{
// verifico oggetto
const ISurfTriMesh* pSTM = GetSurfTriMesh( pGeoObj) ;
@@ -284,25 +267,21 @@ Export3MF::ExportSTM( const string& sName, const IGeoObj* pGeoObj, const Frame3d
}
if ( vVertices.size() == 0 || vTriangles.size() == 0) {
LOG_ERROR( GetEExLogger(), ( "Export3MF : surface \"" + sName + "\" is empty. Ignored.").c_str()) ;
LOG_ERROR( GetEExLogger(), "Export3MF : empty surface ignored") ;
return true ;
}
// creo mesh 3MF
PMeshObject meshObject = m_model->AddMeshObject() ;
if ( ! meshObject) {
if ( meshObject == nullptr) {
LOG_ERROR( GetEExLogger(), "Export3MF : Error on lib3mf Mesh Object")
return false ;
}
meshObject->SetName( sName) ;
meshObject->SetGeometry( vVertices, vTriangles) ;
// assegno il colore
if ( pCol != nullptr) {
Lib3MF_uint32 nColId = ColorHandler3MF( pCol) ;
meshObject->SetObjectLevelProperty( 1, nColId) ;
}
// assegno il nome
if ( ! sName.empty())
meshObject->SetName( sName) ;
// assegno le info
PMetaDataGroup metaDataGrp = meshObject->GetMetaDataGroup() ;
for ( const string& sInfo : vInfo) {
@@ -310,60 +289,79 @@ Export3MF::ExportSTM( const string& sName, const IGeoObj* pGeoObj, const Frame3d
SplitFirst( sInfo, "=", sKey, sVal) ;
metaDataGrp->AddMetaData( sInfoNamespace, sKey, sVal, "xs:string", 0) ;
}
// assegno il colore
Lib3MF_uint32 nColId = ColorHandler3MF( cCol) ;
meshObject->SetObjectLevelProperty( 1, nColId) ;
// aggiungo al modello
if ( pParent == nullptr)
m_model->AddBuildItem( meshObject.get(), m_wrapper->GetIdentityTransform()) ;
else
pParent->AddComponent( meshObject.get(), m_wrapper->GetIdentityTransform()) ;
m_model->AddBuildItem( meshObject.get(), m_wrapper->GetIdentityTransform()) ;
return true ;
}
//----------------------------------------------------------------------------
bool
Export3MF::ScanGroup( const IGdbIterator& iIter)
Export3MF::ExportGroup( const IGdbIterator& iIter, const string& sName, const STRVECTOR& vsInfo, PComponentsObject pParent,
bool bSaveAsComponent)
{
// creo un iteratore
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( iIter.GetGDB())) ;
if ( IsNull( pIter))
return false ;
// scandisco il gruppo
bool bOk = true ;
for ( bool bNext = pIter->GoToFirstInGroup( iIter) ;
bNext ;
bNext = pIter->GoToNext()) {
if ( ! ExportObject( *pIter))
bOk = false ;
PComponentsObject pComponent = pParent ;
// se il layer va salvato come componente, la creo
if ( bSaveAsComponent) {
pComponent = m_model->AddComponentsObject() ;
if ( ! sName.empty())
pComponent->SetName( sName) ;
}
// salvo le info sulla componente ( se il gruppo viene esportato come tale) o sul modello
PMetaDataGroup metaDataGrp ;
if ( bSaveAsComponent)
metaDataGrp = pComponent->GetMetaDataGroup() ;
else
metaDataGrp = m_model->GetMetaDataGroup() ;
for ( const string& sInfo : vsInfo) {
string sKey, sVal ;
SplitFirst( sInfo, "=", sKey, sVal) ;
metaDataGrp->AddMetaData( sInfoNamespace, sKey, sVal, "xs:string", 0) ;
}
return bOk ;
}
// scandisco il gruppo per inserire i suoi oggetti
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( iIter.GetGDB())) ;
if ( IsNull( pIter))
return false ;
for ( bool bNext = pIter->GoToFirstInGroup( iIter) ; bNext ; bNext = pIter->GoToNext()) {
if ( ! ExportObject( *pIter, pComponent, true))
return false ;
}
//----------------------------------------------------------------------------
bool
Export3MF::GetColor( Color& pCol, const IGeomDB * pGDB, const int& nId)
{
if ( nId == GDB_ID_NULL)
return false ;
if ( ! pGDB->GetMaterial( nId, pCol))
// se fallisce cerco il colore del parent
return GetColor( pCol, pGDB, pGDB->GetParentId( nId)) ;
// se il gruppo va salvato come componente, lo aggiungo al modello
if ( bSaveAsComponent && pComponent->GetComponentCount() > 0) {
if ( pParent == nullptr)
m_model->AddBuildItem( pComponent.get(), m_wrapper->GetIdentityTransform()) ;
else
pParent->AddComponent( pComponent.get(), m_wrapper->GetIdentityTransform()) ;
}
return true ;
}
//----------------------------------------------------------------------------
Lib3MF_uint32
Export3MF::ColorHandler3MF( const Color* pCol)
Export3MF::ColorHandler3MF( const Color& cCol)
{
PColorGroup pColorGrp = m_model->GetColorGroupByID( 1) ;
// converto il colore nel formato usato da 3MF
Lib3MF_uint8 nAlpha = ( int)( pCol->GetIntAlpha() * 2.55 + 0.5) ;
sColor cCol3mf = m_wrapper->RGBAToColor( pCol->GetIntRed(), pCol->GetIntGreen(), pCol->GetIntBlue(), nAlpha) ;
// verifico se il colore � gi� presente nel colorgroup
Lib3MF_uint8 nAlpha = ( int)( cCol.GetIntAlpha() * 2.55 + 0.5) ;
sColor cCol3mf = m_wrapper->RGBAToColor( cCol.GetIntRed(), cCol.GetIntGreen(), cCol.GetIntBlue(), nAlpha) ;
// verifico se il colore è già presente nel colorgroup
UINTVECTOR vColorIdx ;
pColorGrp->GetAllPropertyIDs( vColorIdx) ;
for ( Lib3MF_uint32 i : vColorIdx) {
sColor cColTmp = pColorGrp->GetColor( i) ;
if ( cColTmp.m_Red == cCol3mf.m_Red && cColTmp.m_Green == cCol3mf.m_Green && cColTmp.m_Blue == cCol3mf.m_Blue
&& cColTmp.m_Alpha == cCol3mf.m_Alpha)
if ( cColTmp.m_Red == cCol3mf.m_Red && cColTmp.m_Green == cCol3mf.m_Green && cColTmp.m_Blue == cCol3mf.m_Blue &&
cColTmp.m_Alpha == cCol3mf.m_Alpha)
return i ;
}
// se non fosse presente, lo aggiungo
Export3MF.h
+12 -12
View File
@@ -13,7 +13,7 @@
#pragma once
#define NOMINMAX
#define NOMINMAX
#include "/EgtDev/Extern/Lib3MF/Include/lib3mf_implicit.hpp"
#include "/EgtDev/Include/EExExport3MF.h"
@@ -32,20 +32,20 @@ class Export3MF : public IExport3MF
}
private :
bool ExportObject( const IGdbIterator& iIter) ;
bool ScanGroup( const IGdbIterator& iIter) ;
bool TestFilter( int nLev, int nMode, int nStat, bool bGroup) ;
bool ExportObject( const IGdbIterator& iIter, Lib3MF::PComponentsObject pParent = nullptr, bool bSaveGrpAsComponent = false) ;
bool ExportGroup( const IGdbIterator& iIter, const std::string& sName, const STRVECTOR& vsInfo, Lib3MF::PComponentsObject pParent,
bool bSaveAsComponent) ;
bool ExportSFR( const IGeoObj* pGeoObj, const Frame3d& frFrame, const std::string& sName, const STRVECTOR& vInfo,
const Color& cCol, Lib3MF::PComponentsObject pParent) ;
bool ExportSTM( const IGeoObj* pGeoObj, const Frame3d& frFrame, const std::string& sName, const STRVECTOR& vInfo,
const Color& cCol, Lib3MF::PComponentsObject pParent) ;
bool TestFilter( int nLev, int nMode, int nStat, bool bGroup) const ;
bool CalcGroupFilter( void) ;
bool ExportSFR( const std::string& sName, const IGeoObj* pGeoObj, const Frame3d& frFrame, const Color* pCol,
const STRVECTOR& vInfo) ;
bool ExportSTM( const std::string& sName, const IGeoObj* pGeoObj, const Frame3d& frFrame, const Color* pCol,
const STRVECTOR& vInfo) ;
Lib3MF_uint32 ColorHandler3MF( const Color* pCol) ;
bool GetColor( Color& pCol, const IGeomDB * pGBD, const int& nId) ;
Lib3MF_uint32 ColorHandler3MF( const Color& cCol) ;
private :
int m_nFilter ; // filtro su livello, modo e stato, se l'oggetto da valutare � un oggetto geometrico
int m_nGroupFilter ; // filtro su livello, modo e stato, se l'oggetto da valutare � un gruppo
int m_nFilter ; // filtro su livello, modo e stato, se l'oggetto da valutare è un oggetto geometrico
int m_nGroupFilter ; // filtro su livello, modo e stato, se l'oggetto da valutare è un gruppo
Lib3MF::PWrapper m_wrapper ; // lib3mf wrapper
Lib3MF::PModel m_model ; // lib3mf model
} ;
Import3MF.cpp
+104 -212
View File
@@ -18,7 +18,7 @@
#include "Import3MF.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"
using namespace std ;
using namespace Lib3MF ;
@@ -27,16 +27,16 @@ using namespace Lib3MF ;
IImport3MF*
CreateImport3MF( void)
{
// verifico la chiave e le opzioni
// verifico la chiave e le opzioni
if ( ! VerifyKey( KEYOPT_EEX_INPBASE))
return nullptr ;
// creo l'oggetto
// creo l'oggetto
return static_cast<IImport3MF*> ( new( nothrow) Import3MF) ;
}
//----------------------------------------------------------------------------
bool
Import3MF::Import( const string& sFile, IGeomDB* pGDB, int nIdGroup)
Import3MF::Import( const string& sFile, IGeomDB* pGDB, int nIdGroup, int nFlag)
{
LOG_INFO( GetEExLogger(), ( "Import3MF : " + sFile).c_str()) ;
@@ -53,7 +53,10 @@ Import3MF::Import( const string& sFile, IGeomDB* pGDB, int nIdGroup)
return false ;
}
m_nIdGroup = nIdGroup ;
// imposto le opzioni di importazione
m_nFlag = nFlag ;
try {
if ( ! DoImport( sFile))
return false ;
@@ -71,15 +74,15 @@ bool
Import3MF::DoImport( const string& sFile)
{
// libreria 3MF
PWrapper m_wrapper = CWrapper::loadLibrary() ;
if ( ! m_wrapper) {
m_wrapper = CWrapper::loadLibrary() ;
if ( m_wrapper == nullptr) {
LOG_ERROR( GetEExLogger(), " Import3MF : Error on lib3mf Wrapper") ;
return false ;
}
// creazione del 3MF model
m_model = m_wrapper->CreateModel() ;
if ( ! m_model) {
if ( m_model == nullptr) {
LOG_ERROR( GetEExLogger(), " Import3MF : Error on lib3mf Model") ;
return false ;
}
@@ -87,33 +90,34 @@ Import3MF::DoImport( const string& sFile)
// lettura file
PReader reader = m_model->QueryReader( "3mf") ;
reader->ReadFromFile( sFile) ;
for ( Lib3MF_uint32 iWarning = 0 ; iWarning < reader->GetWarningCount() ; iWarning ++) {
for ( Lib3MF_uint32 nWarning = 0 ; nWarning < reader->GetWarningCount() ; nWarning ++) {
Lib3MF_uint32 nErrorCode ;
string sWarningMsg = reader->GetWarning( iWarning, nErrorCode) ;
string sErrorMsg = " Reading 3MF file encountered warning # " + to_string( nErrorCode) + " : " + sWarningMsg ;
string sWarningMsg = reader->GetWarning( nWarning, nErrorCode) ;
string sErrorMsg = " Reading 3MF file encountered warning # " + to_string( nErrorCode) + " : " + sWarningMsg ;
LOG_ERROR( GetEExLogger(), sErrorMsg.c_str()) ;
}
switch ( m_model->GetUnit()) {
case eModelUnit::MicroMeter :
m_nScaleFactor = 0.001 ;
m_dScaleFactor = 0.001 ;
break ;
case eModelUnit::MilliMeter :
m_nScaleFactor = 1.0 ;
m_dScaleFactor = 1.0 ;
break ;
case eModelUnit::CentiMeter :
m_nScaleFactor = 10.0 ;
m_dScaleFactor = 10.0 ;
break ;
case eModelUnit::Inch :
m_nScaleFactor = 25.4 ;
m_dScaleFactor = 25.4 ;
break ;
case eModelUnit::Foot :
m_nScaleFactor = 304.8 ;
m_dScaleFactor = 304.8 ;
break ;
case eModelUnit::Meter :
m_nScaleFactor = 1000.0 ;
m_dScaleFactor = 1000.0 ;
break ;
default:
m_nScaleFactor = 1.0 ;
m_dScaleFactor = 1.0 ;
}
// analisi metadata
@@ -121,83 +125,54 @@ Import3MF::DoImport( const string& sFile)
Lib3MF_uint32 nMetaDataCount = metaDataGrp->GetMetaDataCount() ;
for ( Lib3MF_uint32 i = 0 ; i < nMetaDataCount ; i ++) {
PMetaData metaData = metaDataGrp->GetMetaData( i) ;
string sMetaDataValue = metaData->GetValue() ;
string sMetaDataName = metaData->GetName() ;
if ( ! sMetaDataValue.empty() && ! sMetaDataName.empty())
m_pGDB->SetInfo( m_nIdGroup, sMetaDataName, sMetaDataValue) ;
string sName = metaData->GetName() ;
string sValue = metaData->GetValue() ;
if ( ! sName.empty() && ! sValue.empty())
m_pGDB->SetInfo( m_nIdGroup, sName, sValue) ;
}
// scorro gli items nel build node
PBuildItemIterator pBuildItemsIter = m_model->GetBuildItems() ;
while ( pBuildItemsIter->MoveNext()) {
if ( ! ReadItem( pBuildItemsIter->GetCurrent()))
return false ;
PBuildItem pItem = pBuildItemsIter->GetCurrent() ;
// ignoro i suoi attributes e i suoi metadata
// recupero la sua trasformazione
sTransform sTransf = pItem->GetObjectTransform() ;
// lettura oggetto associato
if ( ! ReadObject( pItem->GetObjectResource(), sTransf, m_nIdGroup))
return false ;
}
return true ;
}
//----------------------------------------------------------------------------------------------------
bool
Import3MF::ReadItem( const PBuildItem pItem)
{
if ( ! pItem)
return false ;
// trasformazione
sTransform sTransf = pItem->GetObjectTransform() ;
// attributes
ATTRVECTOR vAttr ;
string sProp = pItem->GetPartNumber() ;
if ( ! sProp.empty())
vAttr.push_back( make_pair( "Item partnumber", pItem->GetPartNumber())) ;
bool bUUID ;
sProp = pItem->GetUUID( bUUID) ;
if ( bUUID)
vAttr.push_back( make_pair( "Item UUID", sProp)) ;
// metadata
PMetaDataGroup pMetaDataGrp = pItem->GetMetaDataGroup() ;
if ( pMetaDataGrp)
ReadMetaDataGroup( pMetaDataGrp, vAttr, Item) ;
// lettura oggetto associato
return ReadObject( pItem->GetObjectResource(), vAttr, sTransf) ;
}
//-------------------------------------------------------------------------------------------------
bool
Import3MF::ReadObject( const PObject pObj, ATTRVECTOR& vAttr, sTransform& sTransf)
Import3MF::ReadObject( const PObject pObj, const sTransform& Transform, int nParentId)
{
if ( ! pObj)
if ( pObj == nullptr)
return false ;
bool bMeshObj = pObj->IsMeshObject() ;
// attributes
string sProp = pObj->GetName() ;
INFOVECTOR vInfo ;
string sName = pObj->GetName() ;
string sProp = pObj->GetPartNumber() ;
if ( ! sProp.empty())
vAttr.push_back( make_pair( "name", sProp)) ;
sProp = pObj->GetPartNumber() ;
if ( ! sProp.empty())
vAttr.push_back( make_pair( "partnumber", sProp)) ;
vInfo.emplace_back( "PartNumber", sProp) ;
bool bUUID = false ;
sProp = pObj->GetUUID( bUUID) ;
if ( bUUID) {
string sPropName = bMeshObj ? "UUID" : "object UUID" ;
vAttr.push_back( make_pair( sPropName, sProp)) ;
}
if ( bUUID)
vInfo.emplace_back( "UUID", sProp) ;
switch ( pObj->GetType()) {
case eObjectType::Model :
vAttr.push_back( make_pair( "type", "Model")) ;
vInfo.emplace_back( "Type", "Model") ;
break ;
case eObjectType::Support :
vAttr.push_back( make_pair( "type", "Support")) ;
vInfo.emplace_back( "Type", "Support") ;
break ;
case eObjectType::SolidSupport :
vAttr.push_back( make_pair( "type", "SolidSupport")) ;
vInfo.emplace_back( "Type", "SolidSupport") ;
break ;
default :
break ;
@@ -205,29 +180,34 @@ Import3MF::ReadObject( const PObject pObj, ATTRVECTOR& vAttr, sTransform& sTrans
// metadata
PMetaDataGroup pMetaDataGrp = pObj->GetMetaDataGroup() ;
if ( pMetaDataGrp)
ReadMetaDataGroup( pMetaDataGrp, vAttr, bMeshObj ? Mesh : Component) ;
for ( Lib3MF_uint32 i = 0 ; i < pMetaDataGrp->GetMetaDataCount() ; i ++) {
PMetaData metaData = pMetaDataGrp->GetMetaData( i) ;
string sMetaDataName = metaData->GetName() ;
string sMetaDataValue = metaData->GetValue() ;
if ( ! sMetaDataName.empty() && ! sMetaDataValue.empty())
vInfo.emplace_back( sMetaDataName, sMetaDataValue) ;
}
if ( pObj->IsMeshObject())
return ReadMesh( pObj->GetResourceID(), vAttr, sTransf) ;
return ReadMesh( pObj->GetResourceID(), sName, vInfo, Transform, nParentId) ;
else if ( pObj->IsComponentsObject())
return ReadComponents( pObj->GetResourceID(), vAttr, sTransf) ;
return ReadComponent( pObj->GetResourceID(), sName, vInfo, Transform, nParentId) ;
return false ;
}
//----------------------------------------------------------------------------------------------------------------
bool
Import3MF::ReadMesh( const Lib3MF_uint32& nId, ATTRVECTOR& vAttr, sTransform& sTransf)
Import3MF::ReadMesh( Lib3MF_uint32 nId, const string& sName, const INFOVECTOR& vInfo, const sTransform& Transform, int nParentId)
{
// Recupero puntatore alla mesh 3MF
PMeshObject pMesh = m_model->GetMeshObjectByID( nId) ;
if ( pMesh.get() == nullptr)
if ( pMesh == nullptr)
return false ;
// Creo e inizializzo trimesh
PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
if ( IsNull( pStm) || ! pStm->Init( 3, 1)) {
if ( IsNull( pStm) || ! pStm->Init( pMesh->GetVertexCount(), pMesh->GetTriangleCount())) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : ISurfTriMesh Create error") ;
return false ;
}
@@ -240,15 +220,15 @@ Import3MF::ReadMesh( const Lib3MF_uint32& nId, ATTRVECTOR& vAttr, sTransform& sT
// applico la trasformazione
double x = 0.0, y = 0.0, z = 0.0 ;
for ( int k = 0 ; k < 3 ; k ++) {
x += pVertex.m_Coordinates[k] * sTransf.m_Fields[k][0] ;
y += pVertex.m_Coordinates[k] * sTransf.m_Fields[k][1] ;
z += pVertex.m_Coordinates[k] * sTransf.m_Fields[k][2] ;
x += pVertex.m_Coordinates[k] * Transform.m_Fields[k][0] ;
y += pVertex.m_Coordinates[k] * Transform.m_Fields[k][1] ;
z += pVertex.m_Coordinates[k] * Transform.m_Fields[k][2] ;
}
x += sTransf.m_Fields[3][0] ;
y += sTransf.m_Fields[3][1] ;
z += sTransf.m_Fields[3][2] ;
x += Transform.m_Fields[3][0] ;
y += Transform.m_Fields[3][1] ;
z += Transform.m_Fields[3][2] ;
// inserisco il vertice nella trimesh
if ( pStm->AddVertex( Point3d( x, y, z)) == SVT_NULL) {
if ( pStm->AddVertex( Point3d( x, y, z) * m_dScaleFactor) == SVT_NULL) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : ISurfTriMesh AddVertex error") ;
return false ;
}
@@ -275,7 +255,7 @@ Import3MF::ReadMesh( const Lib3MF_uint32& nId, ATTRVECTOR& vAttr, sTransform& sT
}
// Inserimento nel DB geometrico
int nGeoId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nIdGroup, Release( pStm)) ;
int nGeoId = m_pGDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) ;
if ( nGeoId == GDB_ID_NULL) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : error adding GeoObject") ;
return false ;
@@ -290,125 +270,65 @@ Import3MF::ReadMesh( const Lib3MF_uint32& nId, ATTRVECTOR& vAttr, sTransform& sT
}
// attributes
for ( size_t i = 0 ; i < vAttr.size() ; i++) {
if ( vAttr[i].first == "name")
m_pGDB->SetName( nGeoId, vAttr[i].second) ;
else
m_pGDB->SetInfo( nGeoId, vAttr[i].first, vAttr[i].second) ;
}
if ( ! sName.empty())
m_pGDB->SetName( nGeoId, sName) ;
for ( int i = 0 ; i < int( vInfo.size()) ; i++)
m_pGDB->SetInfo( nGeoId, vInfo[i].first, vInfo[i].second) ;
return true ;
#if 0
PMeshObject pMesh = m_model->GetMeshObjectByID( nId) ;
StmFromTriangleSoup Stm ;
if ( ! Stm.Start()) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : StmFromTriangleSoup error") ;
return false ;
}
// vertici
vector<Point3d> vVertices( pMesh->GetVertexCount()) ;
for ( Lib3MF_uint32 i = 0 ; i < pMesh->GetVertexCount() ; i ++) {
sPosition pVertex = pMesh->GetVertex( i) ;
// applico la trasformazione
double x = 0.0, y = 0.0, z = 0.0 ;
for ( Lib3MF_uint32 k = 0 ; k < 3 ; k ++) {
x += pVertex.m_Coordinates[k] * sTransf.m_Fields[k][0] ;
y += pVertex.m_Coordinates[k] * sTransf.m_Fields[k][1] ;
z += pVertex.m_Coordinates[k] * sTransf.m_Fields[k][2] ;
}
x += sTransf.m_Fields[3][0] ;
y += sTransf.m_Fields[3][1] ;
z += sTransf.m_Fields[3][2] ;
Point3d pt( x, y, z) ;
vVertices[i] = pt * m_nScaleFactor ;
}
// triangoli
for ( Lib3MF_uint32 i = 0 ; i < pMesh->GetTriangleCount() ; i ++) {
sTriangle tTrg = pMesh->GetTriangle( i) ;
if ( ! Stm.AddTriangle( vVertices[tTrg.m_Indices[0]], vVertices[tTrg.m_Indices[1]], vVertices[tTrg.m_Indices[2]])) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : StmFromTriangleSoup AddTriangle error") ;
return false ;
}
}
if ( ! Stm.End()) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : StmFromTriangleSoup error") ;
return false ;
}
ISurfTriMesh* pSurf = Stm.GetSurf() ;
if ( pSurf == nullptr) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : StmFromTriangleSoup GetSurf error") ;
return false ;
}
int nGeoId = m_pGDB->AddGeoObj( GDB_ID_NULL, m_nIdGroup, pSurf) ;
if ( nGeoId == GDB_ID_NULL) {
LOG_ERROR( GetEExLogger(), " Error reading 3MF mesh : error adding GeoObject") ;
return false ;
}
// colore
Lib3MF_uint32 pid, pindex ;
if ( pMesh->GetObjectLevelProperty( pid, pindex)) {
Color cCol ;
if ( FindColor( pid, pindex, cCol))
m_pGDB->SetMaterial( nGeoId, cCol) ;
}
// attributes
for ( size_t i = 0 ; i < vAttr.size() ; i++) {
if ( vAttr[i].first == "name")
m_pGDB->SetName( nGeoId, vAttr[i].second) ;
else
m_pGDB->SetInfo( nGeoId, vAttr[i].first, vAttr[i].second) ;
}
return true ;
#endif
}
//-----------------------------------------------------------------------------------
bool
Import3MF::ReadComponents( const Lib3MF_uint32& nId, ATTRVECTOR& attributes, sTransform& sTransfItem)
Import3MF::ReadComponent( Lib3MF_uint32 nId, const string& sName, const INFOVECTOR& vInfo, const sTransform& Transform, int nParentId)
{
PComponentsObject pComponents = m_model->GetComponentsObjectByID( nId) ;
// se va conservata la gerarchia ogni componente corrisponde ad un layer, altrimenti gli elementi della componente vengono
// inseriti direttamente in m_nIdGroup e i suoi attributes vengono ignorati
// Scorro tutte le componenti
for ( Lib3MF_uint32 iC = 0 ; iC < pComponents->GetComponentCount() ; iC ++ ) {
PComponentsObject pComponents = m_model->GetComponentsObjectByID( nId) ;
if ( pComponents == nullptr)
return false ;
int nLayerId = nParentId ;
// se importo gerarchia creo il layer corrispondente alla componente
if ( ( m_nFlag & EI3FLAG_KEEP_GROUPS) != 0) {
nLayerId = m_pGDB->AddGroup( GDB_ID_NULL, nParentId, GLOB_FRM) ;
// assegno nome e info
if ( ! sName.empty())
m_pGDB->SetName( nLayerId, sName) ;
for ( int i = 0 ; i < int( vInfo.size()) ; i++)
m_pGDB->SetInfo( nLayerId, vInfo[i].first, vInfo[i].second) ;
}
// scorro tutti i suoi oggetti
for ( Lib3MF_uint32 nC = 0 ; nC < pComponents->GetComponentCount() ; nC++) {
PComponent pComponent = pComponents->GetComponent( iC) ;
sTransform sTransfComp = pComponent->GetTransform() ;
// combino le trasformazioni
sTransform sTransfRes ;
// inizializzo sTransfRes a zero
PComponent pComponent = pComponents->GetComponent( nC) ;
// combino le trasformazioni
sTransform TransfComp = pComponent->GetTransform() ;
sTransform TransfRes ;
// inizializzo TransfRes a zero
for ( Lib3MF_uint32 i = 0 ; i < 4 ; i++)
fill( sTransfRes.m_Fields[i], sTransfRes.m_Fields[i] + 3, ( Lib3MF_single)0.0) ;
fill( TransfRes.m_Fields[i], TransfRes.m_Fields[i] + 3, ( Lib3MF_single) 0.0) ;
for ( Lib3MF_uint32 i = 0 ; i < 4 ; i ++)
for ( Lib3MF_uint32 j = 0 ; j < 3 ; j++)
for ( Lib3MF_uint32 k = 0 ; k < 3 ; k ++)
sTransfRes.m_Fields[i][j] += sTransfComp.m_Fields[i][k] * sTransfItem.m_Fields[k][j] ; // prodotto fra matrici
TransfRes.m_Fields[i][j] += TransfComp.m_Fields[i][k] * Transform.m_Fields[k][j] ; // prodotto fra matrici
for ( Lib3MF_uint32 j = 0 ; j < 3 ; j ++)
sTransfRes.m_Fields[3][j] += sTransfItem.m_Fields[3][j] ;
TransfRes.m_Fields[3][j] += Transform.m_Fields[3][j] ;
if ( ! ReadObject( pComponent->GetObjectResource(), attributes, sTransfRes))
if ( ! ReadObject( pComponent->GetObjectResource(), TransfRes, nLayerId))
return false ;
}
return true ;
}
//------------------------------------------------------------------------------------
bool
Import3MF::FindColor( const Lib3MF_uint32& pid, const Lib3MF_uint32& pindex, Color& cCol)
Import3MF::FindColor( Lib3MF_uint32 pid, Lib3MF_uint32 pindex, Color& cCol) const
{
sColor sCol ;
@@ -431,12 +351,12 @@ Import3MF::FindColor( const Lib3MF_uint32& pid, const Lib3MF_uint32& pindex, Col
// multiproperty corrispondente a pindex
UINTVECTOR pindices ;
pMultiPropGrp->GetMultiProperty( pindex, pindices) ;
// analizzo i layers alla ricerca di una proprietà che definisca un colore
// analizzo i layers alla ricerca di una proprietà che definisca un colore
Lib3MF_uint32 nLayers = pMultiPropGrp->GetLayerCount() ;
for ( Lib3MF_uint32 i = 0 ; i < nLayers ; i ++) {
sMultiPropertyLayer layer = pMultiPropGrp->GetLayer( i) ;
Lib3MF_uint32 pidLayer = layer.m_ResourceID ;
// appena trovo una propietà che definisce un colore mi fermo
// appena trovo una propietà che definisce un colore mi fermo
if ( m_model->GetPropertyTypeByID( pidLayer) == ePropertyType::BaseMaterial ||
m_model->GetPropertyTypeByID( pidLayer) == ePropertyType::Colors)
return FindColor( pidLayer, pindices[i], cCol) ;
@@ -453,19 +373,19 @@ Import3MF::FindColor( const Lib3MF_uint32& pid, const Lib3MF_uint32& pindex, Col
// check sui valori in vComposite
double dMixSum = 0.0 ;
for( size_t i = 0 ; i < vComposite.size(); i ++)
for( int i = 0 ; i < int( vComposite.size()) ; i ++)
dMixSum += vComposite[i].m_MixingRatio ;
// se fossero tutti zero, considero proporzioni uguali per ogni colore
if ( abs( dMixSum) < EPS_SMALL) {
dMixSum = vComposite.size() ;
for ( size_t i = 0 ; i < vComposite.size() ; i++)
for ( int i = 0 ; i < int( vComposite.size()) ; i++)
vComposite[i].m_MixingRatio = 1 ;
}
double dRed = 0.0, dGreen = 0.0, dBlue = 0.0, dAlpha = 0.0 ; // colore finale
Lib3MF_uint8 nRedTmp, nGreenTmp, nBlueTmp, nAlphaTmp ; // colore del BaseMaterial
// per ogni elemento di composite aggiungo il suo colore con l'opportuno coefficiente
for ( size_t i = 0 ; i < vComposite.size() ; i++) {
for ( int i = 0 ; i < int( vComposite.size()) ; i++) {
sCol = pBaseMatGrp->GetDisplayColor( vComposite[i].m_PropertyID) ;
m_wrapper->ColorToRGBA( sCol, nRedTmp, nGreenTmp, nBlueTmp, nAlphaTmp) ;
double dMixingRatio = vComposite[i].m_MixingRatio / dMixSum ;
@@ -490,31 +410,3 @@ Import3MF::FindColor( const Lib3MF_uint32& pid, const Lib3MF_uint32& pindex, Col
return true ;
}
//----------------------------------------------------------------------------------------------------
bool
Import3MF::ReadMetaDataGroup( const PMetaDataGroup pMetaDataGrp, ATTRVECTOR& vAttr, const MDGCaller& caller)
{
for ( Lib3MF_uint32 i = 0 ; i < pMetaDataGrp->GetMetaDataCount() ; i ++) {
PMetaData metaData = pMetaDataGrp->GetMetaData( i) ;
string sMetaDataValue = metaData->GetValue() ;
if ( sMetaDataValue.empty())
continue ;
string sMetaDataName ;
switch ( caller) {
case Item :
sMetaDataName = "Item " ;
break ;
case Component :
sMetaDataName = "Object " ;
break ;
case Mesh :
sMetaDataName = "" ;
}
sMetaDataName += metaData->GetName() ;
vAttr.push_back( make_pair( sMetaDataName, sMetaDataValue)) ;
}
return true ;
}
Import3MF.h
+17 -18
View File
@@ -13,39 +13,38 @@
#pragma once
#include <unordered_map>
#include "/EgtDev/Include/EExImport3MF.h"
#include "pugixml.hpp"
#include "/EgtDev/Extern/libzip/Include/zip.h"
#define NOMINMAX
#include "pugixml.hpp"
#include "/EgtDev/Include/EExImport3MF.h"
#include "/EgtDev/Extern/libzip/Include/zip.h"
#include "/EgtDev/Extern/Lib3MF/Include/lib3mf_implicit.hpp"
#include <unordered_map>
//----------------------------------------------------------------------------
class Import3MF : public IImport3MF
{
private :
typedef std::vector<std::pair<std::string, std::string>> ATTRVECTOR ;
enum MDGCaller { Item = 0, Component = 1, Mesh = 2 } ;
typedef std::vector<std::pair<std::string, std::string>> INFOVECTOR ;
public :
virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup) ;
virtual bool Import( const std::string& sFile, IGeomDB* pGDB, int nIdGroup, int nFlag = 0) ;
private :
bool DoImport( const std::string& sFile) ;
bool ReadItem( const Lib3MF::PBuildItem item) ;
bool ReadObject( const Lib3MF::PObject pObj, ATTRVECTOR& vAttr, Lib3MF::sTransform& sTransf) ;
bool ReadComponents( const Lib3MF_uint32& nId, ATTRVECTOR& vAttr, Lib3MF::sTransform& sTransfItem) ;
bool ReadMesh( const Lib3MF_uint32& nId, ATTRVECTOR& vAttr, Lib3MF::sTransform& sTransfr) ;
bool ReadMetaDataGroup( const Lib3MF::PMetaDataGroup pMetaDataGrp, ATTRVECTOR& vAttr, const MDGCaller& caller) ;
bool FindColor( const Lib3MF_uint32& pid, const Lib3MF_uint32& pindex, Color& cCol) ;
bool ReadObject( const Lib3MF::PObject pObj, const Lib3MF::sTransform& Transform, int nParentId) ;
bool ReadComponent( Lib3MF_uint32 nId, const std::string& sName, const INFOVECTOR& vInfo, const Lib3MF::sTransform& Transform,
int nParentId) ;
bool ReadMesh( Lib3MF_uint32 nId, const std::string& sName, const INFOVECTOR& vInfo, const Lib3MF::sTransform& Transfrorm,
int nParentId) ;
bool FindColor( Lib3MF_uint32 pid, Lib3MF_uint32 pindex, Color& cCol) const ;
private :
double m_nScaleFactor ;
private :
double m_dScaleFactor ;
IGeomDB* m_pGDB ;
int m_nIdGroup ;
int m_nFlag ;
Lib3MF::PWrapper m_wrapper ;
Lib3MF::PModel m_model ;
} ;