Dario Sassi
709 lines
25 KiB
C++
709 lines
25 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2023
|
|
//----------------------------------------------------------------------------
|
|
// File : Export3dm.cpp Data : 21.09.23 Versione :
|
|
// Contenuto : Implementazione della classe per l'esportazione in formato 3dm.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 21.09.23 DB Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "Export3dm.h"
|
|
#include "DllMain.h"
|
|
#include "/EgtDev/Include/EE3DllMain.h"
|
|
#include "/EgtDev/Include/EGkGeomDB.h"
|
|
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
|
|
#include "/EgtDev/Include/EGkSurfTriMesh.h"
|
|
#include "/EgtDev/Include/EGkSurfBezier.h"
|
|
#include "/EgtDev/Include/EGkCurveLine.h"
|
|
#include "/EgtDev/Include/EGkCurveArc.h"
|
|
#include "/EgtDev/Include/EGkCurveBezier.h"
|
|
#include "/EgtDev/Include/EGkCurveComposite.h"
|
|
#include "/EgtDev/Include/EGkGdbIterator.h"
|
|
#include "/EgtDev/Include/EGkGeoObjType.h"
|
|
#include "/EgtDev/Include/EGkGeoPoint3d.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
#include "/EgtDev/Include/SELkKeyProc.h"
|
|
#include "/EgtDev/Include/EgtKeyCodes.h"
|
|
#include "/EgtDev/Include/EgtStringConverter.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
#include "/EgtDev/Include/EGnStringUtils.h"
|
|
#include "/EgtDev/Extern/opennurbs/Include/opennurbs.h"
|
|
#include <fstream>
|
|
#include <map>
|
|
|
|
|
|
using namespace std ;
|
|
//N.B.:
|
|
// se si vuole richiamare qualche variabile di default definita in una classe come statica e a cui viene assegnato un valore
|
|
// nel file opennurbs_statics.cpp bisogna richiamarla in questo elenco per evitare problemi di compilazione ( errore di LINK)
|
|
|
|
//----------------------------------------------------------------------------
|
|
IExport3dm*
|
|
CreateExport3dm( void)
|
|
{
|
|
// verifico la chiave e le opzioni
|
|
if ( ! VerifyKey( KEYOPT_EEX_EXPBASE))
|
|
return nullptr ;
|
|
// creo l'oggetto
|
|
return static_cast<IExport3dm*> ( new( nothrow) Export3dm) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::SetOptions( int nFilter)
|
|
{
|
|
m_nFilter = nFilter ;
|
|
CalcGroupFilter() ;
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static void
|
|
Internal_SetExampleModelProperties( ONX_Model& model, const char* source_file_name)
|
|
{
|
|
const bool bHaveFileName = ( nullptr != source_file_name && 0 != source_file_name[0]) ;
|
|
if ( ! bHaveFileName)
|
|
source_file_name = "" ;
|
|
|
|
model.m_sStartSectionComments = "This file was created using openNURBS to convert an .nge into .3dm" ;
|
|
|
|
// set application information
|
|
const ON_wString wide_source_file_name( source_file_name) ;
|
|
|
|
model.m_properties.m_Application.m_application_URL = L"http://www.opennurbs.org" ;
|
|
|
|
// set revision history information
|
|
model.m_properties.m_RevisionHistory.NewRevision() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::Export( IGeomDB* pGDB, int nId, const string& sFile)
|
|
{
|
|
Internal_SetExampleModelProperties( m_model, sFile.c_str()) ;
|
|
ON::Begin() ;
|
|
// verifico il DB geometrico
|
|
if ( pGDB == nullptr) {
|
|
LOG_ERROR( GetEE3Logger(), "Export3dm : Error on GeomDB")
|
|
return false ;
|
|
}
|
|
|
|
// verifico l'Id dell'oggetto da esportare
|
|
if ( ! pGDB->ExistsObj( nId)) {
|
|
LOG_ERROR( GetEE3Logger(), "Export3dm : Error on Id")
|
|
return false ;
|
|
}
|
|
|
|
//// file settings ( units, tolerances, views, ...)
|
|
//// OPTIONAL - change values from defaults
|
|
m_model.m_settings.m_ModelUnitsAndTolerances.m_unit_system = ON::LengthUnitSystem::Millimeters ;
|
|
m_model.m_settings.m_ModelUnitsAndTolerances.m_absolute_tolerance = 0.01 ;
|
|
m_model.m_settings.m_ModelUnitsAndTolerances.m_angle_tolerance = ON_PI/180.0 ;// radians
|
|
m_model.m_settings.m_ModelUnitsAndTolerances.m_relative_tolerance = 0.01 ;// 1%
|
|
m_model.m_settings.m_current_material_source = ON::object_material_source::material_from_object ;
|
|
m_model.m_settings.m_RenderSettings.m_bFlatShade = true ;
|
|
|
|
// creo un iteratore
|
|
PtrOwner<IGdbIterator> pIter( CreateGdbIterator( pGDB)) ;
|
|
if ( IsNull( pIter))
|
|
return false ;
|
|
pIter->GoTo( nId) ;
|
|
// esporto l'oggetto e i suoi eventuali figli
|
|
bool bOk = ExportObject( *pIter, 0) ;
|
|
|
|
// stampo il file
|
|
int version = 7 ;
|
|
// errors printed to stdout
|
|
ON_TextLog error_log ;
|
|
// writes model to archive
|
|
bOk = bOk && m_model.Write( ConvertString( sFile).c_str(), version, &error_log) ;
|
|
|
|
ON::End() ;
|
|
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportObject( const IGdbIterator& iIter, const int& nLayer)
|
|
{
|
|
// recupero il livello dell'oggetto
|
|
int nLev = GDB_LV_USER ;
|
|
iIter.GetCalcLevel( nLev) ;
|
|
// recupero il modo dell'oggetto
|
|
int nMode = GDB_MD_STD ;
|
|
iIter.GetCalcMode( nMode) ;
|
|
// recupero lo stato dell'oggetto
|
|
int nStat = GDB_ST_ON ;
|
|
iIter.GetCalcStatus( nStat) ;
|
|
int nType = iIter.GetGdbType() ;
|
|
// se il filtro lo abilita
|
|
if ( TestFilter( nLev, nMode, nStat, nType == GDB_TY_GROUP)) {
|
|
switch ( nType) {
|
|
case GDB_TY_GEO :
|
|
{
|
|
// recupero il riferimento globale dell'oggetto
|
|
Frame3d frFrame ;
|
|
if ( ! iIter.GetGlobFrame( frFrame))
|
|
return false ;
|
|
//recupero il colore dell'oggetto
|
|
Color cCol ;
|
|
iIter.GetCalcMaterial( cCol) ;
|
|
// recupero eventuale nome
|
|
string sName ;
|
|
if ( ! iIter.GetName( sName))
|
|
sName = ToString( iIter.GetId()) ;
|
|
// emetto l'oggetto
|
|
switch ( iIter.GetGeoType()) {
|
|
case GEO_PNT3D: {
|
|
if ( ! ExportPnt( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
}
|
|
case SRF_BEZIER: {
|
|
if ( ! ExportSrfBz( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
}
|
|
case SRF_FLATRGN :
|
|
case SRF_TRIMESH :
|
|
if ( ! ExportSTM( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
case CRV_ARC : {
|
|
if ( ! ExportCrvArc( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
}
|
|
case CRV_BEZIER : {
|
|
if ( ! ExportCrvBezier( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
}
|
|
case CRV_COMPO : {
|
|
if ( ! ExportCrvCompo( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
}
|
|
case CRV_LINE : {
|
|
if ( ! ExportCrvLine( sName, iIter, frFrame, cCol, nLayer))
|
|
return false ;
|
|
break ;
|
|
}
|
|
default :
|
|
break ;
|
|
}
|
|
}
|
|
return true ;
|
|
case GDB_TY_GROUP: {
|
|
int nLayer = iIter.GetId() ;
|
|
if ( nLayer == 0) {
|
|
m_model.RemoveModelComponent( ON_ModelComponent::Type::Layer, m_model.LayerFromIndex( 0).ModelComponentId()) ;
|
|
return ScanGroup( iIter, nLayer) ;
|
|
}
|
|
// creo il layer e setto le proprietà
|
|
ON_Layer* layer = new ON_Layer() ;
|
|
std::string sLayName ;
|
|
iIter.GetName( sLayName) ;
|
|
if ( sLayName == "" ) {
|
|
sLayName = "Layer " + ToString( nLayer) ;
|
|
}
|
|
layer->SetName( ConvertString( sLayName).c_str()) ;
|
|
layer->SetIndex( nLayer) ;
|
|
ON_Color onCol( 0, 0, 0) ; // black
|
|
layer->SetColor( onCol) ;
|
|
layer->SetVisible( true) ;
|
|
layer->SetLocked( false) ;
|
|
int nParent = iIter.GetParentId() ;
|
|
if ( nParent != 0) {
|
|
// setto il parent
|
|
const ON_Layer* onParLay = ON_Layer::Cast( m_model.LayerFromIndex( m_mLayer[nParent]).ModelComponent()) ;
|
|
layer->SetParentLayerId( onParLay->Id()) ;
|
|
}
|
|
// copio le info
|
|
STRVECTOR vStrInfo, vStrInfo_split ;
|
|
iIter.GetAllInfo( vStrInfo) ;
|
|
for ( string sInfo : vStrInfo) {
|
|
Tokenize( sInfo, "=", vStrInfo_split) ;
|
|
layer->SetUserString( ConvertString( vStrInfo_split[0]).c_str(), ConvertString( vStrInfo_split[1]).c_str()) ;
|
|
}
|
|
|
|
// aggiungo il layer
|
|
ON_ModelComponentReference mcr = m_model.AddManagedModelComponent( layer) ;
|
|
int nIndex = mcr.ModelComponentIndex() ;
|
|
m_mLayer.insert( pair< int, int>( nLayer, nIndex)) ;
|
|
|
|
// esploro il gruppo
|
|
return ScanGroup( iIter, nIndex) ;
|
|
}
|
|
default :
|
|
return false ;
|
|
}
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::AddObjectToModel( const IGdbIterator& iIter, ON_Object* onObject, const int& nLayer, const std::string& sName, const Color& cCol,
|
|
ON_3dmObjectAttributes* pOnAttr)
|
|
{
|
|
if ( pOnAttr == nullptr)
|
|
pOnAttr = new ON_3dmObjectAttributes() ;
|
|
pOnAttr->m_layer_index = nLayer ;
|
|
pOnAttr->m_name = ConvertString( sName).c_str() ;
|
|
pOnAttr->SetColorSource( ON::color_from_object) ;
|
|
//N.B. RHINO ha i valori di Alpha invertiti rispetto ai nostri, oltre che su una scala diversa! per loro 0 = opaco e 255 = trasparente
|
|
// per noi invece 0 = trasparente, 100 = opaco
|
|
ON_Color onCol( cCol.GetIntRed(), cCol.GetIntGreen(), cCol.GetIntBlue(), abs( int( cCol.GetIntAlpha() * 2.55) - 255)) ;
|
|
pOnAttr->m_color = onCol ;
|
|
// se è una mesh aggiungo il materiale
|
|
if ( const ON_Mesh* onMesh = ON_Mesh::Cast( onObject)) {
|
|
// aggiungo il materiale al modello se necessario
|
|
std::string sCol = ToString(cCol.GetIntRed()) + "," + ToString( cCol.GetIntGreen()) + "," + ToString( cCol.GetIntBlue()) ;
|
|
if ( m_mMaterial.find( sCol) == m_mMaterial.end()) {
|
|
ON_Material* onMat = new ON_Material ;
|
|
ON_Color onCAmb( 126, 126, 126) ; // gray126
|
|
onMat->m_reflection_glossiness = 0.0 ;
|
|
onMat->SetEmission( onCol) ;
|
|
onMat->SetDiffuse( onCol) ;
|
|
onMat->SetAmbient( onCAmb) ;
|
|
onMat->SetReflectivity( 0) ;
|
|
ON_ModelComponentReference mcr = m_model.AddManagedModelComponent( onMat) ;
|
|
int nIndex = mcr.ModelComponentIndex() ;
|
|
m_mMaterial.insert( pair< std::string, int>( sCol, nIndex)) ;
|
|
pOnAttr->SetMaterialSource( ON::object_material_source::material_from_object) ;
|
|
pOnAttr->m_material_index = nIndex ;
|
|
}
|
|
// sennò richiamo un materiale già definito
|
|
else {
|
|
pOnAttr->SetMaterialSource( ON::object_material_source::material_from_object) ;
|
|
pOnAttr->m_material_index = m_mMaterial[sCol] ;
|
|
}
|
|
}
|
|
// copio le info
|
|
STRVECTOR vStrInfo, vStrInfo_split ;
|
|
iIter.GetAllInfo(vStrInfo) ;
|
|
for ( string sInfo : vStrInfo) {
|
|
Tokenize( sInfo, "=", vStrInfo_split) ;
|
|
pOnAttr->SetUserString( ConvertString( vStrInfo_split[0]).c_str(), ConvertString( vStrInfo_split[1]).c_str()) ;
|
|
}
|
|
// aggiungo al modello
|
|
ON_ModelComponentReference mcr = m_model.AddManagedModelGeometryComponent( onObject, pOnAttr) ;
|
|
return ! mcr.IsEmpty() ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::AddInfoToObject( const IGdbIterator& iIter, ON_Object* onObject)
|
|
{
|
|
// copio le info
|
|
STRVECTOR vStrInfo, vStrInfo_split ;
|
|
iIter.GetAllInfo( vStrInfo) ;
|
|
for ( string sInfo : vStrInfo) {
|
|
Tokenize( sInfo, "=", vStrInfo_split) ;
|
|
onObject->SetUserString( ConvertString( vStrInfo_split[0]).c_str(), ConvertString( vStrInfo_split[1]).c_str()) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::TestFilter( int nLev, int nMode, int nStat, bool bGroup)
|
|
{
|
|
int nFilter = bGroup ? m_nGroupFilter : m_nFilter ;
|
|
if ( ( nLev == GDB_LV_USER && ( nFilter & EEXFLT_LEVUSER) == 0) ||
|
|
( nLev == GDB_LV_SYSTEM && ( nFilter & EEXFLT_LEVSYSTEM) == 0) ||
|
|
( nLev == GDB_LV_TEMP && ( nFilter & EEXFLT_LEVTEMP) == 0))
|
|
return false ;
|
|
if ( ( nMode == GDB_MD_STD && ( nFilter & EEXFLT_MODESTD) == 0) ||
|
|
( nMode == GDB_MD_LOCKED && ( nFilter & EEXFLT_MODELOCKED) == 0) ||
|
|
( nMode == GDB_MD_HIDDEN && ( nFilter & EEXFLT_MODEHIDDEN) == 0))
|
|
return false ;
|
|
if ( ( nStat == GDB_ST_OFF && ( nFilter & EEXFLT_STAOFF) == 0) ||
|
|
( nStat == GDB_ST_ON && ( nFilter & EEXFLT_STAON) == 0) ||
|
|
( nStat == GDB_ST_SEL && ( nFilter & EEXFLT_STASEL) == 0))
|
|
return false ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::CalcGroupFilter( void)
|
|
{
|
|
m_nGroupFilter = 0 ;
|
|
// Status
|
|
if ( ( m_nFilter & EEXFLT_STASEL) != 0)
|
|
m_nGroupFilter += EEXFLT_STASEL + EEXFLT_STAOFF + EEXFLT_STAON ;
|
|
else if ( ( m_nFilter & EEXFLT_STAOFF) != 0)
|
|
m_nGroupFilter += EEXFLT_STAOFF + EEXFLT_STAON ;
|
|
else
|
|
m_nGroupFilter += EEXFLT_STAON ;
|
|
// Mode
|
|
if ( ( m_nFilter & EEXFLT_MODELOCKED) != 0)
|
|
m_nGroupFilter += EEXFLT_MODELOCKED + EEXFLT_MODEHIDDEN + EEXFLT_MODESTD ;
|
|
else if ( ( m_nFilter & EEXFLT_MODEHIDDEN) != 0)
|
|
m_nGroupFilter += EEXFLT_MODEHIDDEN + EEXFLT_MODESTD ;
|
|
else
|
|
m_nGroupFilter += EEXFLT_MODESTD ;
|
|
// Level
|
|
if ( ( m_nFilter & EEXFLT_LEVSYSTEM) != 0)
|
|
m_nGroupFilter += EEXFLT_LEVSYSTEM + EEXFLT_LEVTEMP + EEXFLT_LEVUSER ;
|
|
else if ( ( m_nFilter & EEXFLT_LEVTEMP) != 0)
|
|
m_nGroupFilter += EEXFLT_LEVTEMP + EEXFLT_LEVUSER ;
|
|
else
|
|
m_nGroupFilter += EEXFLT_LEVUSER ;
|
|
|
|
return true ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportPnt(const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<IGeoPoint3d> pGeoPnt( GetGeoPoint3d( pGeoObj->Clone())) ;
|
|
if ( IsNull( pGeoPnt))
|
|
return false ;
|
|
// lo porto nel riferimento globale
|
|
pGeoPnt->ToGlob( frFrame) ;
|
|
Point3d pt = pGeoPnt->GetPoint() ;
|
|
ON_Point* onPt = new ON_Point( ConvertPoint( pt)) ;
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onPt, nLayer, sName, cCol) ; ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportSrfBz( const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
|
|
//MANCA DA IMPLEMENTARE IL TRIM DELLE SUPERFICI!!/////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<ISurfBezier> pSrfBz( GetSurfBezier( pGeoObj->Clone())) ;
|
|
if ( IsNull( pSrfBz))
|
|
return false ;
|
|
// lo porto nel riferimento globale
|
|
pSrfBz->ToGlob( frFrame) ;
|
|
bool bOk = true ;
|
|
int nDegU, nDegV, nSpanU, nSpanV ;
|
|
bool bRat = false ;
|
|
bool bTrimmed = false ;
|
|
pSrfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrimmed) ;
|
|
int nCPU = nDegU * nSpanU + 1 ;
|
|
int nCPV = nDegV * nSpanV + 1 ;
|
|
ON_NurbsSurface* onNurbsSurf = new ON_NurbsSurface( 3, bRat, nDegU + 1, nDegV + 1, nCPU, nCPV) ;
|
|
for ( int u = 0 ; u < nCPU ; ++u) {
|
|
for ( int v = 0 ; v < nCPV ; ++v) {
|
|
Point3d ptCV = pSrfBz->GetControlPoint( u, v, &bOk) ;
|
|
if ( ! bRat) {
|
|
onNurbsSurf->SetCV( u, v, ConvertPoint( ptCV)) ;
|
|
}
|
|
else {
|
|
double dW = pSrfBz->GetControlWeight( u, v, &bOk) ;
|
|
onNurbsSurf->SetCV( u, v, ConvertPoint( ptCV * dW)) ;
|
|
onNurbsSurf->SetWeight( u, v, dW) ;
|
|
}
|
|
}
|
|
}
|
|
// imposto il vettore dei nodi in U
|
|
int nKnotCountU = nDegU + nCPU - 1 ;
|
|
double dKnot = 0 ;
|
|
// per costruzione nKnotCount é un multiplo di nDegU
|
|
for ( int u = 0 ; u < int ( nKnotCountU / nDegU) ; ++u) {
|
|
for ( int p = 0 ; p < nDegU ; ++p)
|
|
onNurbsSurf->SetKnot( 0, u * nDegU + p, dKnot) ;
|
|
++dKnot ;
|
|
}
|
|
|
|
// imposto il vettore dei nodi in V
|
|
int nKnotCountV = nDegV + nCPV - 1 ;
|
|
dKnot = 0 ;
|
|
// per costruzione nKnotCount é un multiplo di nDegU
|
|
for ( int v = 0 ; v < int ( nKnotCountV / nDegV) ; ++v) {
|
|
for ( int p = 0 ; p < nDegV ; ++p)
|
|
onNurbsSurf->SetKnot( 0, v * nDegV + p, dKnot) ;
|
|
++dKnot ;
|
|
}
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onNurbsSurf, nLayer, sName, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportSTM( const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<ISurfTriMesh> pSrfTm ;
|
|
if ( pGeoObj->GetType() == SRF_TRIMESH)
|
|
pSrfTm.Set( GetSurfTriMesh( pGeoObj->Clone())) ;
|
|
else {
|
|
const ISurfFlatRegion* pSrfFr = GetSurfFlatRegion( pGeoObj) ;
|
|
const ISurfTriMesh* pSrfTm_ = pSrfFr->GetAuxSurf() ;
|
|
if ( pSrfTm_ == nullptr){
|
|
return false ;
|
|
}
|
|
pSrfTm.Set( pSrfTm_->Clone()) ;
|
|
}
|
|
|
|
if ( IsNull( pSrfTm))
|
|
return false ;
|
|
|
|
// lo porto nel frame globale
|
|
pSrfTm->ToGlob( frFrame) ;
|
|
|
|
int nVertices = pSrfTm->GetVertexCount() ;
|
|
int nTriangles = pSrfTm->GetTriangleCount() ;
|
|
ON_Mesh* onMesh = new ON_Mesh ;
|
|
for ( int v = 0 ; v < nVertices ; ++v) {
|
|
Point3d pt ; pSrfTm->GetVertex( v, pt) ;
|
|
onMesh->SetVertex( v, ConvertPoint( pt)) ;
|
|
}
|
|
for ( int t = 0 ; t < nTriangles ; ++t) {
|
|
int nIdVert[3] ; pSrfTm->GetTriangle( t, nIdVert) ;
|
|
onMesh->SetTriangle( t, nIdVert[0], nIdVert[1], nIdVert[2]) ;
|
|
}
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onMesh, nLayer, sName, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ON_ArcCurve*
|
|
Export3dm::ConvertCrvArc( const ICurveArc* pCrvArc)
|
|
{
|
|
double dRad = pCrvArc->GetRadius() ;
|
|
Point3d ptCen ;
|
|
pCrvArc->GetCenterPoint( ptCen) ;
|
|
PtrOwner<ON_ArcCurve> onArcCrv( new ON_ArcCurve()) ;
|
|
if ( ! pCrvArc->IsACircle()) {
|
|
Vector3d vtZ = pCrvArc->GetNormVersor() ;
|
|
Vector3d vtX, vtY ;
|
|
vtX = pCrvArc->GetStartVersor() ;
|
|
vtY = vtZ ^ vtX ;
|
|
double dAngDeg = pCrvArc->GetAngCenter() ;
|
|
ON_Plane onPlane( ConvertPoint( ptCen), ConvertVector( vtX), ConvertVector( vtY)) ;
|
|
onArcCrv.Set( new ON_ArcCurve( ON_Arc( onPlane, dRad, dAngDeg * DEGTORAD))) ;
|
|
}
|
|
else
|
|
onArcCrv.Set( new ON_ArcCurve ( ON_Circle( ConvertPoint( ptCen), dRad))) ;
|
|
return Release( onArcCrv) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportCrvArc( const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<ICurveArc> pCrvArc( GetCurveArc( pGeoObj->Clone())) ;
|
|
if ( IsNull( pCrvArc))
|
|
return false ;
|
|
// lo porto nel fram globale
|
|
pCrvArc->ToGlob( frFrame) ;
|
|
ON_ArcCurve* onArcCrv = ConvertCrvArc( pCrvArc) ;
|
|
if ( onArcCrv == nullptr)
|
|
return false ;
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onArcCrv, nLayer, sName, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ON_NurbsCurve*
|
|
Export3dm::ConvertCrvBezier( const ICurveBezier* pCrvBz)
|
|
{
|
|
// creo l'oggetto da esportare
|
|
int nDeg = pCrvBz->GetDegree() ;
|
|
int nCV = nDeg + 1 ;
|
|
PtrOwner<ON_NurbsCurve> onNurbsCrv( new ON_NurbsCurve( 3, // dim
|
|
pCrvBz->IsRational(), // bRat
|
|
nDeg + 1, // order = deg + 1
|
|
nCV)) ; // numero di CP
|
|
// imposto i punti di controllo con gli eventuali pesi
|
|
if ( ! pCrvBz->IsRational()) {
|
|
bool bOk = true ;
|
|
for ( int i = 0 ; i < nCV ; ++i) {
|
|
ON_3dPoint onPt = ConvertPoint( pCrvBz->GetControlPoint( i, &bOk)) ;
|
|
onNurbsCrv->SetCV( i, onPt) ;
|
|
}
|
|
}
|
|
else {
|
|
bool bOk = true ;
|
|
for ( int i = 0 ; i < nCV ; ++i) {
|
|
ON_3dPoint onPt = ConvertPoint( pCrvBz->GetControlPoint( i, &bOk)) ;
|
|
double dWeight = pCrvBz->GetControlWeight( i, &bOk) ;
|
|
onNurbsCrv->SetCV( i, onPt * dWeight) ;
|
|
onNurbsCrv->SetWeight( i, dWeight) ;
|
|
}
|
|
}
|
|
// imposto il vettore dei nodi
|
|
int nKnotCount = nDeg + nCV - 1 ;
|
|
double dKnot = 0 ;
|
|
for ( int u = 0 ; u < int ( nKnotCount / nDeg) ; ++u) {
|
|
for ( int p = 0 ; p < nDeg ; ++p)
|
|
onNurbsCrv->SetKnot( u * nDeg + p, dKnot) ;
|
|
++dKnot ;
|
|
}
|
|
|
|
return Release( onNurbsCrv) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportCrvBezier( const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<ICurveBezier> pCrvBz( GetCurveBezier( pGeoObj->Clone())) ;
|
|
if ( IsNull( pCrvBz))
|
|
return false ;
|
|
// lo porto nel riferimento globale
|
|
pCrvBz->ToGlob( frFrame) ;
|
|
ON_NurbsCurve* onNurbsCrv = ConvertCrvBezier( pCrvBz) ;
|
|
if ( onNurbsCrv == nullptr)
|
|
return false ;
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onNurbsCrv, nLayer, sName, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportCrvCompo( const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<ICurveComposite> pCrvCompo( GetCurveComposite( pGeoObj->Clone())) ;
|
|
if ( IsNull( pCrvCompo))
|
|
return false ;
|
|
// lo porto nel riferimento globale
|
|
pCrvCompo->ToGlob( frFrame) ;
|
|
ON_PolyCurve* onPolyCrv = new ON_PolyCurve ;
|
|
for ( const ICurve* pCrv = pCrvCompo->GetFirstCurve() ; pCrv != nullptr ; pCrv = pCrvCompo->GetNextCurve()) {
|
|
GeoObjType type = pCrv->GetType() ;
|
|
switch ( type) {
|
|
case CRV_LINE : {
|
|
PtrOwner<ICurveLine> pCrvL( GetCurveLine( pCrv->Clone())) ;
|
|
if ( IsNull( pCrvL)) {
|
|
delete onPolyCrv ;
|
|
return false ;
|
|
}
|
|
ON_LineCurve* onLine = ConvertCrvLine( pCrvL) ;
|
|
if ( onLine == nullptr) {
|
|
delete onPolyCrv ;
|
|
return false ;
|
|
}
|
|
onPolyCrv->Append( onLine) ;
|
|
break ;
|
|
}
|
|
case CRV_ARC : {
|
|
PtrOwner<ICurveArc> pCrvArc( GetCurveArc( pCrv->Clone())) ;
|
|
if ( IsNull( pCrvArc)) {
|
|
delete onPolyCrv ;
|
|
return false ;
|
|
}
|
|
ON_ArcCurve* onArcCrv = ConvertCrvArc( pCrvArc) ;
|
|
if ( onArcCrv == nullptr) {
|
|
delete onPolyCrv ;
|
|
return false ;
|
|
}
|
|
onPolyCrv->Append( onArcCrv) ;
|
|
break ;
|
|
}
|
|
case CRV_BEZIER : {
|
|
PtrOwner<ICurveBezier> pCrvBz( GetCurveBezier( pCrv->Clone())) ;
|
|
if ( IsNull( pCrvBz)) {
|
|
delete onPolyCrv ;
|
|
return false ;
|
|
}
|
|
ON_NurbsCurve* onNurbsCrv = ConvertCrvBezier( pCrvBz) ;
|
|
if ( onNurbsCrv == nullptr) {
|
|
delete onPolyCrv ;
|
|
return false ;
|
|
}
|
|
onPolyCrv->Append( onNurbsCrv) ;
|
|
break ;
|
|
}
|
|
default : break ;
|
|
}
|
|
}
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onPolyCrv, nLayer, sName, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
ON_LineCurve*
|
|
Export3dm::ConvertCrvLine( const ICurveLine* pCrvL)
|
|
{
|
|
Point3d ptStart, ptEnd ;
|
|
pCrvL->GetStartPoint( ptStart) ;
|
|
pCrvL->GetEndPoint( ptEnd) ;
|
|
PtrOwner<ON_LineCurve> onCrvLine( new ON_LineCurve( ON_Line( ConvertPoint( ptStart), ConvertPoint( ptEnd)))) ;
|
|
return Release( onCrvLine) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ExportCrvLine( const string& sName, const IGdbIterator& iIter, const Frame3d& frFrame, const Color& cCol, const int& nLayer)
|
|
{
|
|
// recupero l'oggetto geometrico
|
|
const IGeoObj* pGeoObj = iIter.GetGeoObj() ;
|
|
if ( pGeoObj == nullptr)
|
|
return false ;
|
|
// verifico oggetto
|
|
PtrOwner<ICurveLine> pCrvL( GetCurveLine( pGeoObj->Clone())) ;
|
|
if ( IsNull( pCrvL))
|
|
return false ;
|
|
// lo porto nel frame globale
|
|
pCrvL->ToGlob( frFrame) ;
|
|
ON_LineCurve* onCrvLine = ConvertCrvLine( pCrvL) ;
|
|
// aggiungo l'oggetto al modello
|
|
return AddObjectToModel( iIter, onCrvLine, nLayer, sName, cCol) ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
Export3dm::ScanGroup( const IGdbIterator& iIter, const int& nLayer)
|
|
{
|
|
// 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, nLayer))
|
|
bOk = false ;
|
|
}
|
|
|
|
return bOk ;
|
|
}
|