Egalware/EgtExch3dm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
EgtExch3dm/Import3dm.cpp
T
Daniele Bariletti c9f5421566 EgtExch3dm : 
- tolto codice di debug.
2026-04-01 09:47:50 +02:00

1770 lines
74 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// EgalTech 2023
//----------------------------------------------------------------------------
// File : Import3dm.cpp Data : 23.06.23 Versione : 2.5f1
// Contenuto : Implementazione della classe per l'importazione di 3dm.
//
//
//
// Modifiche : 23.06.23 DB Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "Import3dm.h"
#include "DllMain.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurveLine.h"
#include "/EgtDev/Include/EGkArcSpecial.h"
#include "/EgtDev/Include/EGkCurveComposite.h"
#include "/EgtDev/Include/EGkCurveBezier.h"
#include "/EgtDev/Include/EGkCurveAux.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkSurfAux.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EGkExtDimension.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#include "/EgtDev/Include/EgtKeyCodes.h"
#include "/EgtDev/Include/EGkSbzFromCurves.h"
//#include "/EgtDev/Include/EgtPerfCounter.h"
#define SAVEREVOLVECURVE 0
#define SAVEREVOLVESURF 0
#define SAVEREVOLVETRIM 0
#define SAVETRIMLOOP 0
#if SAVEREVOLVECURVE || SAVEREVOLVESURF || SAVEREVOLVETRIM || SAVETRIMLOOP
#include "/EgtDev/Include/EGkGeoVector3d.h"
#include "/EgtDev/Include/EGkGeoObjSave.h"
#endif
using namespace std ;
////----------------------------------------------------------------------------
// deviazione angolare standard (in gradi)
const double ANG_TOL_FINE = 1 ;
// tolleranza lineare affinata
const double LIN_TOL_FINE = 0.002 ;
const double LIN_TOL_STD = 0.05 ;
//----------------------------------------------------------------------------
IImport3dm*
CreateImport3dm( void)
{
// verifico la chiave e le opzioni
if ( ! VerifyKey( KEYOPT_EEX_INPBASE))
return nullptr ;
// creo l'oggetto
return static_cast<IImport3dm*> ( new( nothrow) Import3dm) ;
}
//----------------------------------------------------------------------------
string
Import3dm::ConvertONwStringToString( ON_wString ON_wString)
{
return wstringtoA( wstring( ON_wString)) ;
}
int ON_nEntity = 0 ;
//----------------------------------------------------------------------------
bool
Import3dm::Import( const string& sFile, IGeomDB* pGDB, int nIdGroup,
double dTextHeight, double dExtLine, double dArrLen, double dTextDist,
bool bLenIsMM, int nDecDig, std::string sFont)
{
// verifico il DB geometrico
if ( pGDB == nullptr) {
LOG_ERROR( GetEE3Logger(), "Import3dm : Error on GeomDB")
return false ;
}
m_pGDB = pGDB ;
m_dTextHeight = dTextHeight ;
m_dExtLine = dExtLine ;
m_dArrLen = dArrLen ;
m_dTextDist = dTextDist ;
m_bLenIsMM = bLenIsMM ;
m_nDecDig = nDecDig ;
m_sFont = sFont ;
// verifico l'Id di gruppo
if ( ! m_pGDB->ExistsObj( nIdGroup)) {
LOG_ERROR( GetEE3Logger(), "Import3dm : Error on IdGroup")
return false ;
}
m_nIdGroup = nIdGroup ;
wstring widestr( sFile.begin(), sFile.end()) ;
const wchar_t* sFileName = widestr.c_str() ;
FILE* archive_fp = ON::OpenFile( sFileName, L"rb") ;
if ( ! archive_fp) {
LOG_ERROR( GetEE3Logger(), "Import3dm : Unable to open file.") ;
return false ;
}
// create achive object from file pointer
ON_BinaryFile archive( ON::archive_mode::read3dm, archive_fp) ;
// read the contents of the file into "model"
ON_TextLog dump ;
bool rc = m_model.Read( archive, &dump) ;
if ( ! rc)
LOG_ERROR( GetEE3Logger(), "Import3dm : Unable to read file.") ;
// close the file
ON::CloseFile( archive_fp) ;
// LAYER
// creo i layer e i conto
ONX_ModelComponentIterator component_iterator_l( m_model, ON_ModelComponent::Type::Layer) ;
int nFirstId = 0 ;
ON_UUID ON_nil_uuid = { 0,0,0,{ 0,0,0,0,0,0,0,0}} ;
//int nLayDelCount = 0 ; //serve solo se si vogliono cancellare i layer parent. Se però questi layer contengono oggetti, che non sono in sottolayer del parent, non verranno visualizzati
for ( const ON_ModelComponent* mc = component_iterator_l.FirstComponent() ; mc != nullptr ; mc = component_iterator_l.NextComponent()) {
ON_UUID uuid = mc->Id() ;
const ON_Layer* onLayer = ON_Layer::Cast( mc) ;
ON_UUID uuidParent = onLayer->ParentId() ;
// cerco se il parent è un layer già aggiunto
auto it = std::find_if( m_mLayer.begin(), m_mLayer.end(),
[uuidParent](pair< int, tuple<const ON_Layer*, ON_UUID, int, int, int>> x){ return !ON_UuidCompare( get<1>(get<1>(x)), uuidParent) ;}); // ON_UuidCompare restituisce 0 se coincidono
int nParentL1 = -1 ;
// risalgo la gerarchia dei layer finché arrivo al primo layer e aggiungo tutti i nomi al nome del sottolayer
string sName = ConvertONwStringToString( onLayer->Name()) ;
bool bIsVisible = onLayer->IsVisible() ;
while ( ON_UuidCompare( uuidParent, ON_nil_uuid) ) {// ON_UuidCompare restituisce 0 se coincidono
const ON_Layer* onParentLayer = get<0>(it->second) ;
string sParentName = ConvertONwStringToString( onParentLayer->Name()) ;
// se sono ad una profondità maggiore di 1 aggiungo il nome del parent
if ( get<3>(it->second) > 1)
sName = sParentName + "_" + sName ;
uuidParent = onParentLayer->ParentId() ;
// salvo l'id del parent che è al livello 1 ( che è un Part)
if ( get<3>( it->second) == 1)
nParentL1 = it->first ;
it = std::find_if( m_mLayer.begin(), m_mLayer.end(),
[uuidParent](pair< int, tuple<const ON_Layer*, ON_UUID, int, int, int>> x){ return !ON_UuidCompare( get<1>(get<1>(x)), uuidParent) ;});
}
// COMMENTO QUESTO TRATTO PERCHé, LASCIO I LAYER PARENT E LI CANCELLO ALLA FINE DELL'IMPORT SOLO SE RESTANO VUOTI
//
//// se era già stato aggiunto il parent e non era già indicata la presenza di sottolayer
//// devo eliminare il parent e mettere a true il flag dei sottolayer nella mappa dei layer
// if ( it_parent != m_mLayer.end() ) {
// if ( !get<3>(it_parent->second) ) {
// get<3>(it_parent->second) = true ;
// m_pGDB->Erase( it_parent->first) ;
// auto LayerDeleted = m_mLayer.extract(it_parent->first);
// LayerDeleted.key() = nLayDelCount ;
// -- nLayDelCount ;
// m_mLayer.insert(std::move(LayerDeleted));
// }
// }
int nDepth = 2 ;
if ( nParentL1 == GDB_ID_NULL) {
nParentL1 = GDB_ID_ROOT ;
nDepth = 1 ;
}
int nIdLayer = m_pGDB->AddGroup( GDB_ID_NULL, nParentL1 , GLOB_FRM) ;
if ( nFirstId == 0)
nFirstId = nIdLayer ;
int nIndex = onLayer->Index() ;
m_mLayer.insert( std::make_pair( nIdLayer, std::make_tuple(onLayer, uuid, nIndex, nDepth, -1))) ;
m_pGDB->SetName( nIdLayer, sName) ;
if( ! bIsVisible)
m_pGDB->SetStatus( nIdLayer, GDB_ST_OFF) ;
}
// OGGETTI GEOMETRICI
ONX_ModelComponentIterator component_iterator( m_model, ON_ModelComponent::Type::ModelGeometry) ;
// se non riesco a convertire un oggetto, lo scarto e incremento il contatore del suo tipo nel dizionario error_count
ON_nEntity = 0 ;
int nId ;
for( const ON_ModelComponent* mc = component_iterator.FirstComponent() ; mc != nullptr ; mc = component_iterator.NextComponent())
{
const ON_ModelGeometryComponent* mgc = ON_ModelGeometryComponent::Cast( mc) ;
ON_wString onwStrName ;
mgc->GetName( onwStrName) ;
string sObjName = ConvertONwStringToString( onwStrName) ;
const ON_Object* oGeometry = mgc->Geometry( nullptr) ;
// individuo a che layer appartiene l'oggetto
const ON_3dmObjectAttributes* attributes = mgc->Attributes( nullptr) ;
int nLayer = attributes->m_layer_index ;
bool bIsObjectVisibile = attributes->IsVisible() ;
ON::object_mode onMode = attributes->Mode() ;
if ( onMode == ON::object_mode::idef_object) {
++ ON_nEntity ;
continue ;
}
// verifico se un oggetto è una instance definition
bool bIsInstanceDefinitionObject = attributes->IsInstanceDefinitionObject() ;
if ( bIsInstanceDefinitionObject){
++ ON_nEntity ;
continue ;
}
if ( nLayer < 0)
nLayer = m_pGDB->GetFirstInGroup( 0) ;
else {
// prendo l'indice che il layer ha nel nostro GDB
auto it = std::find_if(m_mLayer.begin(), m_mLayer.end(),
[nLayer](pair< int, tuple<const ON_Layer*, ON_UUID, int, int, int>> x){ return get<2>(get<1>(x)) == nLayer ;});
nLayer = it->first ;
}
// recupero il colore dell'oggetto
ON_Color onCol ;
switch ( attributes->ColorSource()) {
case ON::color_from_parent: // come se fosse from_layer
case ON::color_from_layer : {
onCol = get<0>(m_mLayer[nLayer])->Color() ;
break ;
}
case ON::color_from_object: {
onCol = attributes->m_color ;
break ;
}
case ON::color_from_material: {
// non gestito
break ;
}
}
Color cCol ;
// 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
cCol.Set( onCol.Red(), onCol.Green(), onCol.Blue(), lround( ( 255 - onCol.Alpha()) / 2.55)) ;
// converto l'oggetto e lo aggiungo al GeomDB
vector<PtrOwner<IGeoObj>> vpGeoObj ;
ConvertGeometry( oGeometry, vpGeoObj) ;
int nSubLayer = -1 ;
// se il layer in cui dovrei mettere l'oggetto è in realtà un part allora creo un layer ausiliario in cui metter gli oggetti che dovrebbero stare in questo part
if ( get<3>(m_mLayer[nLayer]) == 1) {
if ( get<4>(m_mLayer[nLayer]) == -1) {
int nAuxLayer = m_pGDB->AddGroup( GDB_ID_NULL, nLayer, GLOB_FRM) ;
get<4>(m_mLayer[nLayer]) = nAuxLayer ;
}
// recupero l'id del layer ausiliario
nLayer = get<4>(m_mLayer[nLayer]) ;
}
// se ho più oggetti da inserire creo un subLayer
if ( ssize( vpGeoObj) > 1) {
int nParent = m_pGDB->GetParentId( nLayer) ;
nSubLayer = m_pGDB->AddGroup( GDB_ID_NULL, nParent, GLOB_FRM) ;
string sSubName ; m_pGDB->GetName( nSubLayer, sSubName) ;
if ( sSubName == "")
sSubName = "Layer " + ToString(nSubLayer) ;
string sName ; m_pGDB->GetName( nLayer, sName) ;
if ( sName == "")
sName = "Layer " + ToString(nLayer) ;
sSubName = sName + "_" + sSubName ;
m_pGDB->SetName( nSubLayer, sSubName) ;
}
else
nSubLayer = nLayer ;
// recupero eventuali informazioni dell'oggetto
ON_ClassArray<ON_UserString> onvUserString ;
const ON_3dmObjectAttributes* model_geometry_attributes = mgc->Attributes( nullptr) ;
int nInfo = model_geometry_attributes->GetUserStrings( onvUserString) ;
for ( int p = 0 ; p < ssize( vpGeoObj) ; ++p) {
if ( ! IsNull( vpGeoObj[p]) && vpGeoObj[p]->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nSubLayer, Release( vpGeoObj[p])) ;
m_pGDB->SetMaterial( nId, cCol) ;
for ( int i = 0 ; i < nInfo ; ++i) {
m_pGDB->SetInfo( nId, ConvertONwStringToString( onvUserString[i].m_key), ConvertONwStringToString( onvUserString[i].m_string_value)) ;
}
m_pGDB->SetName( nId, sObjName) ;
GdbStatus status = bIsObjectVisibile ? GDB_ST_ON : GDB_ST_OFF ;
m_pGDB->SetStatus( nId, status) ;
////debug
//m_pGDB->SetInfo( nId, "3dmId", ToString(ON_nEntity)) ;
}
}
++ ON_nEntity ;
}
// CANCELLO I LAYER RIMASTI VUOTI ??
// messaggio di errore da mettere nel log per dire quanti oggetti sono stati ignorati perché la conversione non è riuscita
map<string, int>::iterator it = m_mError_count.begin() ;
while (it != m_mError_count.end()) {
string type = it->first ;
int count = it->second ;
string sOut = "Import3dm : " + to_string( count) + " " + type + " objects have been ignored, due to conversion errors" ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
it++;
}
return true ;
}
//----------------------------------------------------------------------------
bool
Import3dm::ConvertGeometry( const ON_Object* oGeometry, vector<PtrOwner<IGeoObj>>& vpGeoObj)
{
ON::object_type type = oGeometry->ObjectType() ;
switch ( type) {
case ON::object_type::point_object : {
const ON_Point* oPoint = ON_Point::Cast( oGeometry) ;
Point3d pt( ConvertPoint( *oPoint)) ;
// lo aggiungo al GeomDB nel layer corretto
PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
if ( ! IsNull( pGeoPnt) && pGeoPnt->Set( pt) && pGeoPnt->IsValid())
vpGeoObj.emplace_back( Release( pGeoPnt)) ;
else
m_mError_count["point"] += 1 ;
break ;
}
case ON::object_type::pointset_object : {
const ON_PointCloud* pc = ON_PointCloud::Cast( oGeometry);
if ( pc == nullptr) {
m_mError_count["pointset"] += 1 ;
break ;
}
for ( int i = 0 ; i < pc->PointCount() ; i++) {
Point3d pt( ConvertPoint( pc->m_P[i])) ;
// lo aggiungo al GeomDB nel layer corretto
PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
if ( ! IsNull( pGeoPnt) && pGeoPnt->Set( pt) && pGeoPnt->IsValid())
vpGeoObj.emplace_back( Release(pGeoPnt)) ;
else
m_mError_count["point"] += 1 ;
}
break ;
}
case ON::object_type::curve_object : {
const ON_Curve* onCurve = ON_Curve::Cast( oGeometry) ;
PtrOwner<ICurve> pCurve( ConvertCurve( onCurve)) ;
if ( ! IsNull( pCurve) && pCurve->IsValid())
vpGeoObj.emplace_back( Release( pCurve)) ;
else
m_mError_count["curve"] += 1 ;
break ;
}
case ON::object_type::surface_object : {
const ON_Surface* onSurface = ON_Surface::Cast( oGeometry) ;
PtrOwner<ISurf> pSurf( ConvertSurface( onSurface)) ;
if ( ! IsNull( pSurf) && pSurf->IsValid())
vpGeoObj.emplace_back( Release( pSurf)) ;
else
m_mError_count["surface"] += 1 ;
break ;
}
case ON::object_type::brep_object : {
const ON_Brep* onBrep = ON_Brep::Cast( oGeometry) ;
ISURFPOVECTOR vpSurf = ConvertBrep( onBrep, false) ;
for ( int k = 0 ; k < int( vpSurf.size()) ; ++ k) {
PtrOwner<ISurf> pSurf( GetSurf( Release( vpSurf[k]))) ;
if ( ! IsNull( pSurf) && pSurf->IsValid())
vpGeoObj.emplace_back( Release( pSurf)) ;
else
m_mError_count["brep"] += 1 ;
}
break ;
}
case ON::object_type::extrusion_object : {
const ON_Extrusion* onExtrusion = ON_Extrusion::Cast( oGeometry) ;
ISURFPOVECTOR vpSurf = ConvertExtrusion( onExtrusion) ;
for ( int k = 0 ; k < int( vpSurf.size()) ; ++ k) {
PtrOwner<ISurf> pSurf( GetSurf( Release( vpSurf[k]))) ;
if ( ! IsNull( pSurf) && pSurf->IsValid())
vpGeoObj.emplace_back( Release( pSurf)) ;
else
m_mError_count["extrusion"] += 1 ;
}
break ;
}
case ON::object_type::mesh_object :{
const ON_Mesh* onMesh = ON_Mesh::Cast( oGeometry) ;
PtrOwner<ISurfTriMesh> pSurfTm( ConvertMesh( onMesh)) ;
if ( ! IsNull( pSurfTm) && pSurfTm->IsValid())
vpGeoObj.emplace_back( Release( pSurfTm)) ;
else
m_mError_count["mesh"] += 1 ;
break ;
}
case ON::object_type::loop_object : {// some type of ON_BrepLoop
// in teoria non dovrei mai trovare questo tipo di oggetti come model geometry indipendenti, ma solo come parte di una brep
const ON_BrepLoop* onBrepLoop = ON_BrepLoop::Cast( oGeometry) ;
PtrOwner<ICurve> pCurve( ConvertBrepLoop( onBrepLoop)) ;
if ( ! IsNull( pCurve) && pCurve->IsValid())
vpGeoObj.emplace_back( Release( pCurve)) ;
else
m_mError_count["loop"] += 1 ;
break ;
}
case ON::object_type::subd_object: {
// non c'è un comando per convertire le subd in altre superfici...
m_mError_count["subd"] += 1 ;
break ;
}
case ON::object_type::annotation_object: {
const ON_Annotation* onAnnot = ON_Annotation::Cast( oGeometry) ;
// recupero il DimStyle
onAnnot->DimensionStyleId() ;
ON_UUID onStyleId = onAnnot->DimensionStyleId() ;
ON_ModelComponentReference mcr = m_model.ComponentFromId( ON_ModelComponent::Type::DimStyle, onStyleId) ;
const ON_ModelComponent* mc = mcr.ModelComponent() ;
const ON_DimStyle* onDimStyle = ON_DimStyle::Cast( mc) ;
// converto l'oggetto
vpGeoObj = ConvertAnnotation( onAnnot, onDimStyle) ;
break ;
}
// TO DO
// oggetto che definisce la zona dell'anteprima di stampa
// degli oggetti potrebbero essere definiti rispetto a questo frame
//
//case ON::object_type::detail_object: {
// const ON_DetailView* onDetail = ON_DetailView::Cast( oGeometry) ;
// ON_NurbsCurve onBoundary = onDetail->m_boundary ;
// ICurve* pCrv = ConvertCurve( &onBoundary) ;
// ON_3dmView onView = onDetail->m_view ;
// ON::view_type onViewType = onView.m_view_type ;
// error_count["detail"] += 1 ;
//}
case ON::object_type::instance_definition: {
string sOut = "instance_definition: object " + ToString( ON_nEntity) ;
LOG_INFO( GetEE3Logger(), sOut.c_str()) ;
break ;
}
case ON::object_type::instance_reference : {
string sOut = "instance_reference: object " + ToString( ON_nEntity) ;
LOG_INFO( GetEE3Logger(), sOut.c_str()) ;
const ON_InstanceRef* onInstRef = ON_InstanceRef::Cast( oGeometry) ;
ON_Xform xform = ON_Xform::DiagonalTransformation( 1) ; // trasformazione identità
ConvertInstanceReference( onInstRef, xform, vpGeoObj) ;
break ;
}
default: {
m_mError_count["other"] += 1 ;
break ;
}
}
return true ;
}
//----------------------------------------------------------------------------
bool
Import3dm::ConvertInstanceReference( const ON_InstanceRef* onInstRef, const ON_Xform& onXForm, vector<PtrOwner<IGeoObj>>& vpGeoObj)
{
const ON_ModelComponentReference& idef_component_ref = m_model.ComponentFromId( ON_ModelComponent::Type::InstanceDefinition, onInstRef->m_instance_definition_uuid) ;
const ON_InstanceDefinition* onInstDef = ON_InstanceDefinition::Cast( idef_component_ref.ModelComponent()) ;
if ( onInstDef)
{
ON_Xform xform = onXForm * onInstRef->m_xform ;
bool bApplyTransform = ( xform.IsValid() && ! xform.IsZero() && ! xform.IsIdentity()) ;
const ON_SimpleArray<ON_UUID>& geometry_id_list = onInstDef->InstanceGeometryIdList() ;
const int geometry_id_count = geometry_id_list.Count() ;
if ( geometry_id_count > 0) {
for ( int i = 0; i < geometry_id_count; i++) {
string sOut = "Importing instRef: GeoC = " + ToString( geometry_id_count) + " i = " + ToString( i) ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
const ON_ModelComponentReference& model_component_ref = m_model.ComponentFromId(ON_ModelComponent::Type::ModelGeometry, geometry_id_list[i]) ;
const ON_ModelGeometryComponent* model_geometry = ON_ModelGeometryComponent::Cast(model_component_ref.ModelComponent()) ;
if ( nullptr != model_geometry) {
const ON_Geometry* onGeometry = model_geometry->Geometry(nullptr) ;
if ( nullptr != onGeometry) {
const ON_InstanceRef* onInstRefNested = ON_InstanceRef::Cast( onGeometry) ;
if ( onInstRefNested) {
ConvertInstanceReference( onInstRefNested, xform, vpGeoObj) ;
}
else {
// Copy the geometry. Note, we are responsible for the memory allocated here.
// So make to dispose of it, otherwise you'll leak memory.
ON_Geometry* onGeometryCopy = onGeometry->Duplicate() ;
if ( nullptr != onGeometryCopy) {
if ( bApplyTransform)
onGeometryCopy->Transform( xform) ;
if ( ! ConvertGeometry( onGeometryCopy, vpGeoObj))
m_mError_count["instance reference"] += 1 ;
delete onGeometryCopy ;
}
else
m_mError_count["instance reference"] += 1 ;
//if ( ! ConvertGeometry( onGeometry, vpGeoObj))
// m_mError_count["instance reference"] += 1 ;
//if ( bApplyTransform) {
// ON_Xform xformInv( xform.m_xform) ;
// xformInv.Transpose() ;
// Frame3d frLoc ;
// Point3d ptOrig (xformInv[0][3], xformInv[1][3], xformInv[2][3]) ;
// Vector3d vtX( xformInv[0][0], xformInv[1][0], xformInv[2][0]) ;
// Vector3d vtY( xformInv[0][1], xformInv[1][1], xformInv[2][1]) ;
// Vector3d vtZ( xformInv[0][2], xformInv[1][2], xformInv[2][2]) ;
// frLoc.Set( ptOrig, vtX, vtY, vtZ) ;
// frLoc.Invert() ;
// for ( IGeoObj* pGeo : vpGeoObj)
// pGeo->ToLoc( frLoc) ;
//}
}
}
}
}
}
}
return true ;
}
//----------------------------------------------------------------------------
ICurve*
Import3dm::ConvertCurve( const ON_Curve* onCurve)
{
ON::eCurveType curve_type = onCurve->ON_CurveType() ;
switch ( curve_type) {
case ON::eCurveType::ctArc : {
const ON_ArcCurve* onArc = ON_ArcCurve::Cast( onCurve) ;
Vector3d vStart = ConvertVector( onArc->TangentAt( 0)) ;
Point3d ptCenter( ConvertPoint( onArc->m_arc.plane.origin)) ;
Point3d ptStart( ConvertPoint( onArc->m_arc.PointAt( onArc->m_arc.Domain().Min()))) ;
Point3d ptEnd( ConvertPoint( onArc->m_arc.PointAt( onArc->m_arc.Domain().Max()))) ;
Vector3d vtN = ConvertVector( onArc->m_arc.plane.zaxis) ;
PtrOwner<ICurveArc> pCurveArc( CreateCurveArc()) ;
if ( IsNull( pCurveArc))
return nullptr ;
if ( ! AreSamePointApprox( ptStart, ptEnd)) {
if ( ! pCurveArc->Set2PVN( ptStart, ptEnd, vStart, vtN))
pCurveArc->SetC2PN( ptCenter, ptStart, ptEnd, vtN) ;
}
else {
double dRad = onArc->m_arc.Radius() ;
pCurveArc->Set( ptCenter, vtN, dRad) ;
}
return Release( pCurveArc) ;
break ;
}
case ON::eCurveType::ctCircle : {
const ON_ArcCurve* onCircle = ON_ArcCurve::Cast( onCurve) ;
Point3d ptCenter( ConvertPoint(onCircle->m_arc.plane.origin)) ;
ON_3dVector on_vtN = onCircle->m_arc.plane.zaxis ;
Vector3d vtN = ConvertVector( on_vtN) ;
double dRad = onCircle->m_arc.Radius() ;
PtrOwner<ICurveArc> pCurveArc( CreateCurveArc()) ;
pCurveArc->Set( ptCenter, vtN, dRad) ;
return Release( pCurveArc) ;
break ;
}
case ON::eCurveType::ctLine : {
const ON_LineCurve* onCurveLine = ON_LineCurve::Cast( onCurve) ;
Point3d ptStart( ConvertPoint( onCurveLine->m_line.from)) ;
Point3d ptEnd( ConvertPoint( onCurveLine->m_line.to)) ;
PtrOwner<ICurveLine> pCurveLine( CreateCurveLine()) ;
pCurveLine->Set( ptStart, ptEnd) ;
return Release( pCurveLine) ;
break ;
}
case ON::eCurveType::ctNurbs : {
// da trasformare in una bezier
const ON_NurbsCurve* onNurbsCurve = ON_NurbsCurve::Cast( onCurve) ;
bool bIsRational = onNurbsCurve->IsRational() ;
CNurbsData nuCurve ;
nuCurve.bRat = bIsRational ;
nuCurve.nDeg = onNurbsCurve->Degree() ; // == onNurbsCurve->Order() - 1
int nCount = onNurbsCurve->CVCount() ;
if ( bIsRational) {
// vettore dei punti di controllo
PNTVECTOR vPtCtrl ;
// vettore dei pesi
DBLVECTOR vWeCtrl ;
for( int i = 0 ; i < nCount; ++i) {
ON_4dPoint o4dPoint ;
onNurbsCurve->GetCV( i, o4dPoint) ;
Point3d ptCtrl( ConvertPoint( o4dPoint)) ;
vPtCtrl.push_back( ptCtrl / o4dPoint.w) ;
vWeCtrl.push_back( o4dPoint.w) ;
}
nuCurve.vCP = vPtCtrl ;
nuCurve.vW = vWeCtrl ;
}
else {
// vettore dei punti di controllo
PNTVECTOR vPtCtrl ;
for( int i = 0 ; i < nCount; ++i) {
ON_3dPoint o3dPoint ;
onNurbsCurve->GetCV( i, o3dPoint) ;
Point3d ptCtrl( ConvertPoint(o3dPoint)) ;
vPtCtrl.push_back( ptCtrl) ;
}
nuCurve.vCP = vPtCtrl ;
}
// qui aggiungo un controllo se la curva è collassata in un punto restituisco nullptr
bool bCollapsed = true ;
Point3d ptFirst = nuCurve.vCP.front() ;
for( int i = 1 ; i < int( nuCurve.vCP.size()) ; ++i) {
if ( ! AreSamePointApprox( ptFirst, nuCurve.vCP[i])) {
bCollapsed = false ;
break ;
}
}
if ( bCollapsed)
return nullptr ;
// vettore dei nodi
DBLVECTOR vU ;
int nKnot = onNurbsCurve->KnotCount() ;
for ( int j = 0 ; j < nKnot ; ++j ) {
double dKnot = onNurbsCurve->Knot( j) ;
vU.push_back( dKnot) ;
}
nuCurve.vU = vU ;
nuCurve.bClosed = onNurbsCurve->IsClosed() ;
nuCurve.bPeriodic = onNurbsCurve->IsPeriodic() ;
nuCurve.bClamped = onNurbsCurve->IsClamped(2) ;
// controllo relazione nodi - punti di controllo
int nU = int( nuCurve.vCP.size()) + nuCurve.nDeg - 1 ;
// se ho due nodi di troppo mi basta togliere il primo e l'ultimo per rendere la curva canonica
// se la curva è periodica posso renderla non periodica senza cambiare la forma della curva
if ( nU == int( nuCurve.vU.size()) + 2 || nuCurve.bPeriodic || ! nuCurve.bClamped)
NurbsCurveCanonicalize( nuCurve) ;
// ora che ho riempito la Nurbs con tutti i dati la converto in Bezier
return NurbsToBezierCurve( nuCurve) ;
break ;
}
case ON::eCurveType::ctOnsurface :{
const ON_CurveOnSurface* onCurveOnSurface = ON_CurveOnSurface::Cast( onCurve) ;
ON_NurbsCurve onNurbsCurve ;
onCurveOnSurface->GetNurbForm( onNurbsCurve) ;
return ConvertCurve( &onNurbsCurve) ;
break ;
}
case ON::eCurveType::ctProxy :{
const ON_CurveProxy* onProxyCurve = ON_CurveProxy::Cast( onCurve) ;
const ON_Curve* onCurve = onProxyCurve->ProxyCurve() ;
return ConvertCurve( onCurve) ;
break ;
}
case ON::eCurveType::ctPolycurve : {
const ON_PolyCurve* onPolycurve = ON_PolyCurve::Cast( onCurve) ;
int nCurves = onPolycurve->Count() ;
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
for ( int i = 0 ; i < nCurves; ++i) {
ICurve* pCurveToAdd = nullptr ;
ON_Curve* onCurveToAdd = onPolycurve->SegmentCurve( i) ;
pCurveToAdd = ConvertCurve( onCurveToAdd) ;
pCrvCompo->AddCurve( pCurveToAdd) ;
}
return Release( pCrvCompo) ;
break ;
}
case ON::eCurveType::ctPolyline : {
const ON_PolylineCurve* onPolyline = ON_PolylineCurve::Cast( onCurve) ;
int nPoints = onPolyline->PointCount() ;
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
Point3d ptNew , ptOld( ConvertPoint(onPolyline->m_pline[0])) ;
for ( int i = 1 ; i < nPoints ; ++i ) {
ICurveLine* pCurveLine( CreateCurveLine()) ;
ptNew = ConvertPoint( onPolyline->m_pline[i]) ;
pCurveLine->Set( ptOld, ptNew) ;
pCrvCompo->AddCurve( pCurveLine) ;
ptOld = ptNew ;
}
return Release( pCrvCompo) ;
break ;
}
default :
break ;
}
return nullptr ;
}
//----------------------------------------------------------------------------
ISurf*
Import3dm::ConvertSurface( const ON_Surface* onSurf, DBLVECTOR* vU, DBLVECTOR* vV)
{
if ( const ON_NurbsSurface* onNurbsSurface_ = ON_NurbsSurface::Cast( onSurf)) {
ON_NurbsSurface onNurbsSurface( *onNurbsSurface_) ;
SNurbsSurfData sNurbsSurf ;
sNurbsSurf.bClosedU = onNurbsSurface.IsClosed( 0) ;
sNurbsSurf.bClosedV = onNurbsSurface.IsClosed( 1) ;
sNurbsSurf.bPeriodicU = onNurbsSurface.IsPeriodic( 0) ;
sNurbsSurf.bPeriodicV = onNurbsSurface.IsPeriodic( 1) ;
sNurbsSurf.bClampedU = onNurbsSurface.IsClamped( 0, 2) ; // qui do per scontato che se la curva è clamped alla fine allora lo è anche all'inizio e viceversa
sNurbsSurf.bClampedV = onNurbsSurface.IsClamped( 1, 2) ; // qui do per scontato che se la curva è clamped alla fine allora lo è anche all'inizio e viceversa
sNurbsSurf.bRat = onNurbsSurface.IsRational() ;
sNurbsSurf.nDegU = onNurbsSurface.Degree( 0) ;
sNurbsSurf.nDegV = onNurbsSurface.Degree( 1) ;
sNurbsSurf.nCPU = onNurbsSurface.CVCount( 0) ;
sNurbsSurf.nCPV = onNurbsSurface.CVCount( 1) ;
PNTVECTOR vCPV( sNurbsSurf.nCPV) ;
sNurbsSurf.mCP.resize( sNurbsSurf.nCPU, vCPV) ;
DBLVECTOR vWV( sNurbsSurf.nCPV) ;
sNurbsSurf.mW.resize( sNurbsSurf.nCPU, vWV) ;
for ( int i = 0 ; i < sNurbsSurf.nCPU ; ++i) {
for ( int j = 0 ; j < sNurbsSurf.nCPV ; ++j) {
ON_4dPoint o4dPoint = onNurbsSurface.ControlPoint(i, j) ;
Point3d ptCP = ConvertPoint( o4dPoint) ;
sNurbsSurf.mCP[i][j] = ptCP ;
if ( sNurbsSurf.bRat)
sNurbsSurf.mCP[i][j] = ptCP / o4dPoint.w ;
else
sNurbsSurf.mCP[i][j] = ptCP ;
sNurbsSurf.mW[i][j] = o4dPoint.w ;
}
}
for ( int i = 0 ; i < onNurbsSurface.KnotCount(0) ; ++i )
sNurbsSurf.vU.push_back( onNurbsSurface.Knot( 0, i)) ;
for ( int j = 0 ; j < onNurbsSurface.KnotCount(1) ; ++j )
sNurbsSurf.vV.push_back( onNurbsSurface.Knot( 1, j)) ;
if ( sNurbsSurf.bPeriodicU || sNurbsSurf.bPeriodicV || ! sNurbsSurf.bClampedU || ! sNurbsSurf.bClampedV)
NurbsSurfaceCanonicalize( sNurbsSurf) ;
if ( vU != nullptr) {
*vU = sNurbsSurf.vU ;
*vV = sNurbsSurf.vV ;
}
return NurbsToBezierSurface( sNurbsSurf) ;
}
else if ( const ON_PlaneSurface* onPlaneSurface = ON_PlaneSurface::Cast( onSurf)) {
// recupero i riferimenti del piano e li converto in oggetti nostri
Point3d ptOrig = ConvertPoint( onPlaneSurface->m_plane.origin) ;
Vector3d vtX = ConvertVector( onPlaneSurface->m_plane.xaxis) ;
Vector3d vtY = ConvertVector( onPlaneSurface->m_plane.yaxis) ;
Vector3d vtZ = ConvertVector( onPlaneSurface->m_plane.Normal()) ;
ON_Interval on_inX = onPlaneSurface->Extents(0) ;
ON_Interval on_inY = onPlaneSurface->Extents(1) ;
Point3d pt0( on_inX[0], on_inY[0]) ;
Point3d pt1( on_inX[1], on_inY[0]) ;
Point3d pt2( on_inX[1], on_inY[1]) ;
Point3d pt3( on_inX[0], on_inY[1]) ;
// costruisco la figura e la inserisco nel GDB
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return nullptr ;
pCrvCompo->AddPoint( pt0) ;
pCrvCompo->AddLine( pt1) ;
pCrvCompo->AddLine( pt2) ;
pCrvCompo->AddLine( pt3) ;
pCrvCompo->Close() ;
// porto la figura nel frame globale
Frame3d frPlane ;
frPlane.Set( ptOrig, vtX, vtY, vtZ) ;
pCrvCompo->ToGlob( frPlane) ;
PtrOwner<ISurfFlatRegion> pSurf( CreateSurfFlatRegion()) ;
if ( IsNull( pSurf) || ! pSurf->AddExtLoop( Release( pCrvCompo)))
return nullptr ;
return Release( pSurf) ;
}
else if ( const ON_RevSurface* onRevSurface = ON_RevSurface::Cast( onSurf)) {
PtrOwner<ICurve> pCurve( ConvertCurve( onRevSurface->m_curve)) ;
ON_Line onAxis = onRevSurface->m_axis ;
Point3d ptFrom = ConvertPoint( onAxis.from) ;
Point3d ptTo = ConvertPoint( onAxis.to) ;
Vector3d vtDir = ptTo - ptFrom ;
// intervallo angolare su cui si vuole la superficie di rivoluzione
ON_Interval onInter = onRevSurface->m_angle ;
double dAngRotDeg = ( onInter[1] - onInter[0]) * RADTODEG ;
double dAngStartDeg = onInter[0] * RADTODEG ;
// uso la nurbs form per ottenere i vettori
ON_NurbsSurface onNurbsSurface ;
int nOk = onRevSurface->GetNurbForm( onNurbsSurface) ;
if ( nOk != 0)
return nullptr ;
ConvertSurface( &onNurbsSurface, vU, vV) ;
// provo a convertire usando una bezier
#if SAVEREVOLVECURVE
vector<IGeoObj*> vGeo ;
vGeo.push_back( pCurve->Clone()) ;
IGeoVector3d* pVec = CreateGeoVector3d() ;
pVec->Set( vtDir, ptTo) ;
vGeo.push_back( pCurve->Clone()) ;
vGeo.push_back( pVec) ;
SaveGeoObj( vGeo, "D:\\Temp\\bezier\\import3dm\\revolve_surf\\crv.nge") ;
#endif
PtrOwner<ISurfBezier> pSurfBez( GetSurfBezierByRevolve( pCurve, ptFrom, vtDir, false, 0.01)) ;
#if SAVEREVOLVECURVE
if ( ! IsNull(pSurfBez))
SaveGeoObj( pSurfBez->Clone(), "D:\\Temp\\bezier\\import3dm\\revolve_surf\\srf.nge") ;
#endif
if ( ! IsNull( pSurfBez) && pSurfBez->IsValid())
return Release( pSurfBez) ;
// sennò uso una trimesh
PtrOwner<ISurfTriMesh> pSurf( CreateSurfTriMesh()) ;
if ( IsNull( pSurf))
return nullptr ;
// se l'angolo è significativo allora effettuo la rivoluzione
if ( dAngRotDeg > EPS_SMALL * 10) {
pSurf.Set( GetSurfTriMeshByScrewing( pCurve, ptFrom, vtDir, dAngRotDeg, 0., false)) ;
// se la rivoluzione è meno di un angolo giro e la partenza non era a zero devo ruotare la superficie ottenuta
if ( dAngRotDeg < 360 - EPS_SMALL * 50 && onInter[0] * RADTODEG > EPS_SMALL * 50)
pSurf->Rotate( ptFrom, vtDir, dAngStartDeg) ;
}
return Release( pSurf) ;
}
else if ( const ON_SumSurface* onSumSurface = ON_SumSurface::Cast( onSurf)) {
// uso la nurbs form
ON_NurbsSurface onNurbsSurface ;
int nOk = onSumSurface->GetNurbForm( onNurbsSurface) ;
PtrOwner<ISurf> pSurf ;
if ( nOk != 0)
pSurf.Set( ConvertSurface( &onNurbsSurface, vU, vV)) ;
if ( ! IsNull( pSurf) && pSurf->IsValid())
return Release( pSurf) ;
// se non è riuscita la conversione tento di costruire la superficie con una rail
ON_Interval onIntDomain0 = onSumSurface->Domain(0) ;
ON_Interval onIntDomain1 = onSumSurface->Domain(1) ;
// Note carefully: ON_SumSurface::IsoCurve allocates memory
// for the output curve. The caller is responsible for
// freeing this memory when finished.
PtrOwner<ON_Curve> onpCrvWest( onSumSurface->IsoCurve(1, onIntDomain0[0])) ;
PtrOwner<ON_Curve> onpCrvSouth( onSumSurface->IsoCurve(0, onIntDomain1[0])) ;
PtrOwner<ICurve> pCrvWest( ConvertCurve( onpCrvWest)) ;
PtrOwner<ICurve> pCrvSouth( ConvertCurve( onpCrvSouth)) ;
PtrOwner<ISurfTriMesh> pSurfTm ( GetSurfTriMeshSwept( pCrvSouth, pCrvWest, V_NULL, false)) ;
if ( ! IsNull( pSurfTm) && pSurfTm->IsValid())
return Release( pSurfTm) ;
// se fallisce questo tentativo di conversione allora recupero le curve e costruisco la superficie di Bezier
// in teoria dovrei farcela con uno dei due metodi precedenti
PtrOwner<ON_Curve> onpCrvEast( onSumSurface->IsoCurve(1, onIntDomain0[1])) ;
PtrOwner<ON_Curve> onpCrvNorth( onSumSurface->IsoCurve(0, onIntDomain1[1])) ;
// da implementare ////////////////////////////////////////////////////////////////////////////////////////////////////////////
return nullptr ;
}
else if ( const ON_SurfaceProxy* onSurfaceProxy = ON_SurfaceProxy::Cast( onSurf)) {
PtrOwner<ISurf> pSurf ;
// bool bTransposed = onSurfaceProxy->ProxySurfaceIsTransposed() ;
if ( const ON_BrepFace* onBrepFace = ON_BrepFace::Cast( onSurfaceProxy)) {
// uso la nurbs form
ON_NurbsSurface onNurbsSurface ;
int nOk = onBrepFace->GetNurbForm( onNurbsSurface) ;
if ( nOk != 0){
pSurf.Set( ConvertSurface( & onNurbsSurface, vU, vV)) ;
#if SAVEREVOLVECURVE
SaveGeoObj( pSurf->Clone(), "D:\\Temp\\bezier\\import3dm\\revolve_surf\\srf_nurbs.nge") ;
#endif
}
else {
// QUI PERò NON TENGO CONTO DEL TRIM!!!!!!
//
// se non è riuscita la conversione in nurbs tengo la superficie originale
const ON_Surface* onSurfFace = onBrepFace->ProxySurface() ;
// qui devo applicare a mano le trasformazioni dalla superfice originale alla proxy
// la funzione getNurbsForm lo fa in automatico
pSurf.Set( ConvertSurface( onSurfFace, vU, vV)) ;
LOG_ERROR( GetEE3Logger(), "Import3dm : Importing a surface without its trim, because of conversione errors") ;
}
////// questa versione è da usare per usare le superfici proxy anziché la versione nurbs
//pSurf.Set( ConvertSurface( onBrepFace->ProxySurface(), vU, vV)) ;
}
else if ( const ON_OffsetSurface* onOffsetSurface = ON_OffsetSurface::Cast( onSurfaceProxy)) {
//pSurf.Set( ConvertSurface( onOffsetSurface->BaseSurface())) ;
ON_NurbsSurface onNurbsSurface ;
int nOk = onOffsetSurface->GetNurbForm( onNurbsSurface) ;
if ( nOk != 0)
pSurf.Set( ConvertSurface( &onNurbsSurface, vU, vV)) ;
}
else
pSurf.Set( ConvertSurface( onSurfaceProxy->ProxySurface(), vU, vV)) ;
return Release( pSurf) ;
}
return nullptr ;
}
#if SAVETRIMLOOP
int nLoop = 0 ;
#endif
//----------------------------------------------------------------------------
ISURFPOVECTOR
Import3dm::ConvertBrep( const ON_Brep* onBrep, const bool bForceTriMesh)
{
// se le facce della Brep sono tutte trimesh restituisco un'unica trimesh
// se le facce sono delle NURBS restituisco un vettore di superfici Bezier
// se ForceTriMesh è true allora le Bezier vengono trasformate in trimesh e aggiunte alla zuppa
int nFailedBFace = 0, nFailedTm = 0, nFailedFr = 0, nFailedBz = 0, nFailedBTrim = 0 ;
ISURFPOVECTOR vSurf ;
StmFromTriangleSoup stmSoup ;
if ( ! stmSoup.Start())
return vSurf ;
int nFaceTot = onBrep->m_F.Count() ;
for ( int i = 0 ; i < nFaceTot ; ++i) {
ON_BrepFace* onFace = onBrep->Face( i) ;
bool bOk = true ;
bool bRev = onFace->m_bRev ;
const ON_Surface* onSurface = onFace->SurfaceOf() ;
PtrOwner<ISurf> pSurf ;
bool bTooSmallOnlyLoop = false ;
DBLVECTOR vU, vV ;
if ( const ON_PlaneSurface* onPlaneSurface = ON_PlaneSurface::Cast( onSurface)) {
SurfFlatRegionByContours SfrCntr ;
// ricavo il riferimento del piano
Point3d ptOrig = ConvertPoint( onPlaneSurface->m_plane.origin) ;
Vector3d vtX = ConvertVector( onPlaneSurface->m_plane.xaxis) ;
Vector3d vtY = ConvertVector( onPlaneSurface->m_plane.yaxis) ;
Vector3d vtZ = ConvertVector( onPlaneSurface->m_plane.Normal()) ;
Plane3d plane ; plane.Set( ptOrig, vtZ) ;
int nLoopCount = onFace->LoopCount() ;
for ( int k = 0 ; k < nLoopCount ; ++k) {
PtrOwner<ICurveComposite> pCrvCompo( GetCurveComposite(ConvertBrepLoop( onFace->Loop( k)))) ;
PolyArc paLoopApprox ;
//pCrvCompo->ApproxWithArcs(LIN_TOL_FINE, ANG_TOL_FINE, paLoopApprox) ;
// pCrvCompo->Clear() ; // Da provare, senza questa riga non viene modificata la crvCompo
//pCrvCompo->FromPolyArc( paLoopApprox) ;
pCrvCompo->MergeCurves(LIN_TOL_FINE, ANG_TOL_FINE) ;
#if SAVETRIMLOOP
SaveGeoObj( pCrvCompo->Clone(), "D:\\Temp\\bezier\\import3dm\\import_trim\\loop" + ToString(k) + ".nge") ;
#endif
double dArea = 0 ; pCrvCompo->GetArea( plane, dArea) ;
if ( nLoopCount == 1 && dArea <= 10 * EPS_SMALL)
bTooSmallOnlyLoop = true ;
if ( ! SfrCntr.AddCurve( Release( pCrvCompo)))
++ nFailedBTrim ;
}
pSurf.Set( SfrCntr.GetSurf()) ;
if ( ! IsNull( pSurf) && pSurf->IsValid()) {
// porto le coordinate dal riferimento del piano di trim alle coordinate globali
Frame3d frPlane ;
frPlane.Set( ptOrig, vtX, vtY, vtZ) ;
pSurf->ToGlob( frPlane) ;
}
}
else
pSurf.Set( ConvertSurface( onFace, &vU, &vV)) ;
if ( IsNull( pSurf) || ! pSurf->IsValid()) {
// se la superficie aveva un solo loop e questo era troppo piccolo allora NON lo segno come errore
// semplicmente la superficie non verrà disegnata perché troppo piccola
if ( ! bTooSmallOnlyLoop) {
++ nFailedBFace ;
}
}
else {
// se ho una trimesh o una flatregion la aggiungo alla zuppa, se è una bezier la aggiungo al vettore delle superfici
int nType = pSurf->GetType() ;
if ( nType == SRF_TRIMESH) {
PtrOwner<ISurfTriMesh> pSurfTm( GetSurfTriMesh( Release( pSurf))) ;
if ( !IsNull(pSurfTm) && pSurfTm->IsValid() ) {
if ( bRev)
pSurfTm->Invert() ;
stmSoup.AddSurfTriMesh( *pSurfTm) ;
}
else
++ nFailedTm ;
}
else if ( nType == SRF_FLATRGN) {
PtrOwner<ISurfFlatRegion> pSurfFr( GetSurfFlatRegion( Release( pSurf))) ;
if ( ! IsNull( pSurfFr) && pSurfFr->IsValid()) {
if ( bRev)
pSurfFr->Invert() ;
stmSoup.AddSurfTriMesh(*pSurfFr->GetAuxSurf()) ;
}
else
++ nFailedFr ;
}
else if ( nType == SRF_BEZIER) {
PtrOwner<ISurfBezier> pSurfBezNew( GetSurfBezier( Release( pSurf))) ;
if ( ! IsNull( pSurfBezNew) && pSurfBezNew->IsValid()) {
SurfFlatRegionByContours SfrCntr ;
const ON_Surface* onSurface = onFace->SurfaceOf() ;
// se la superficie era una superficie di rivoluzione, le eventuali curve di trim erano parametrizzate con la coordinata x in radianti,
// e non riferita allo spazio parametrico della nurbs corrispondente ( che sarebbe una nurbs razionale, dovendo approssimare un arco di circonferenza)
// devo quindi prelevare le curve di trim e cambiarne le coordinate per matcharle allo spazio parametrico della nurbs
bool bAddedLoop = false ;
bool bTrimTooSmall = false ;
if ( const ON_RevSurface* onRevSurf = ON_RevSurface::Cast( onSurface) ) {
for ( int k = 0 ; k < onFace->LoopCount(); ++k ) {
ICurve* pCrv( ConvertBrepLoop( onFace->Loop( k))) ;
if ( pCrv == nullptr || ! pCrv->IsValid()) {
++ nFailedBTrim ;
bOk = false ;
break ;
}
// qui devo spostare ogni punto della curva dallo spazio parametrico della superificie rev allo spazio della superficie nurbs
ConvertCurveParam( onRevSurf, &pCrv) ;
PtrOwner<ICurveComposite> pCrvCompo( ApproxTrim( pCrv)) ;
double dArea = 0 ;
pCrvCompo->GetAreaXY(dArea) ;
if (abs(dArea) > EPS_SMALL) {
pCrvCompo->Scale( GLOB_FRM, SBZ_TREG_COEFF, SBZ_TREG_COEFF, 1) ;
if ( SfrCntr.AddCurve( Release(pCrvCompo)))
bAddedLoop = true ;
}
else
bTrimTooSmall = true ;
}
if ( ! bOk)
continue ;
}
else {
for ( int k = 0 ; k < onFace->LoopCount() && bOk ; ++k ) {
PtrOwner<ICurve> pCrv( ConvertBrepLoop( onFace->Loop( k))) ;
#if SAVETRIMLOOP
SaveGeoObj( pCrv->Clone(), "D:\\Temp\\bezier\\import3dm\\import_trim\\loop" + ToString(nLoop) + ".nge") ;
++nLoop ;
#endif
if ( IsNull( pCrv) || ! pCrv->IsValid()) {
++ nFailedBTrim ;
bOk = false ;
break ;
}
PtrOwner<ICurveComposite> pCrvCompo( ApproxTrim( pCrv)) ;
double dArea = 0 ;
pCrvCompo->GetAreaXY(dArea) ;
if (abs(dArea) > EPS_SMALL) { // qui non sarebbe meglio mettere SQ_EPS_SMALL oppure addirittura EPS_ZERO o 0 ?
pCrvCompo->Scale( GLOB_FRM, SBZ_TREG_COEFF, SBZ_TREG_COEFF, 1) ;
if ( SfrCntr.AddCurve( Release( pCrvCompo)))
bAddedLoop = true ;
}
else {
bTrimTooSmall = true ;
continue ;
}
}
if ( ! bOk)
continue ;
}
if ( ! bAddedLoop) {
if ( ! bTrimTooSmall)
++ nFailedBTrim ;
continue ;
}
ISurfFlatRegion* pSfrTrim = SfrCntr.GetSurf() ;
// questa regione di Trim deve essere riferita al rettangolo parametrico totale ( spaz param 1x1 -> regione trim 1000x1000)
// devo anche controllare che il sistema di riferimento dello spazio di trim totale sia giusto ( con l'angolo BottomLeft in (0,0)
//posizonato nel primo quadrante del piano XY)
double u0,u1,v0,v1 ;
onFace->GetDomain(0, &u0, &u1) ;
onFace->GetDomain(1, &v0, &v1) ;
double dScaleU = (u1 - u0) ;
double dScaleV = (v1 - v0) ;
Vector3d vToOrig( -u0, -v0, 0) ;
vToOrig *= SBZ_TREG_COEFF ;
if ( pSfrTrim != nullptr)
pSfrTrim->Translate( vToOrig) ;
else {
++ nFailedBTrim ;
continue ;
}
int nDegU, nDegV, nSpanU, nSpanV ;
bool bRat, bTrim ;
pSurfBezNew->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bRat, bTrim) ;
pSfrTrim->Scale( GLOB_FRM, nSpanU / dScaleU, nSpanV / dScaleV, 1.) ;
// se la superficie di partenza aveva vettori dei nodi non uniformi devo riscalare lo spazio parametrico in modo da renderli uniformi
// applicando così la trasformazione anche alle curve di trim.
ON_NurbsSurface onNurbsSurface ;
onFace->GetNurbForm( onNurbsSurface) ;
// rendo uniforme lo spazio parametrico nella direzione dei parametri che non lo sono
// devo rendere lo spazio parametrico uniforme solo se la superficie è trimmata, sennò non serve
// per capire se la superficie sia trimmata controllo che lo spazio parametrico trimmato non coincida con tutto lo spazio parametrico
double dParamX = nSpanU * SBZ_TREG_COEFF ;
double dParamY = nSpanV * SBZ_TREG_COEFF ;
double dAreaTot = dParamX * dParamY ;
double dAreaTrim = 0 ; pSfrTrim->GetArea( dAreaTrim) ;
if ( dAreaTrim / dAreaTot < 1 - EPS_SMALL) {
bool bRescaled = false ;
DBLVECTOR vU0 , vV0 ;
for ( int i = 0 ; i < ssize(vU) ; ++i)
vU0.push_back( vU[i] * nSpanU / dScaleU) ;
for ( int j = 0 ; j < ssize(vV) ; ++j)
vV0.push_back( vV[j] * nSpanV / dScaleV) ;
dScaleU = dParamX ;
dScaleV = dParamY ;
//if ( ssize( vU0) == 0 || ssize(vV0) == 0 ) {
// vU0.clear() ;
// vV0.clear() ;
// int nU = onFace->SpanCount(0) ;
// int nV = onFace->SpanCount(1) ;
// double* vdU = new double[nU] ;
// double* vdV = new double[nV] ;
// onFace->GetSpanVector(0,vdU) ;
// onFace->GetSpanVector(1,vdV) ;
// for ( int i = 0 ; i < nU ; ++i)
// vU0.push_back( vdU[i] * nSpanU / dScaleU) ;
// for ( int j = 0 ; j < nV ; ++j)
// vV0.push_back( vdV[j] * nSpanU / dScaleU) ;
// delete[] vdU ;
// delete[] vdV ;
// ///////// PER FAR FUNZIONARE LA CANONICALIZE SERVONO ANCHE I PUNTI
// // devo solo togliere i nodi di troppo passando il vettore alla nurbsCanonicalize
// if ( onFace->IsPeriodic(0)) {
// CNurbsData cnU ;
// cnU.bPeriodic = true ;
// cnU.vU = vU0 ;
// NurbsCurveCanonicalize( cnU) ;
// vU0 = cnU.vU ;
// }
// if ( onFace->IsPeriodic(1)) {
// CNurbsData cnV ;
// cnV.bPeriodic = true ;
// cnV.vU = vV0 ;
// NurbsCurveCanonicalize( cnV) ;
// vV0 = cnV.vU ;
// }
//}
#if SAVEREVOLVETRIM
SaveGeoObj( pSfrTrim->Clone(), "D:\\Temp\\bezier\\import3dm\\trim_error\\non_uniform_trim.nge") ;
#endif
if ( ! MakeUniform( pSfrTrim, bRescaled, vU0, vV0, nDegU, nDegV, dScaleU, dScaleV, false)) {
++ nFailedBTrim ;
continue ;
}
pSurfBezNew->SetTrimRegion( *pSfrTrim) ;
}
else
pSfrTrim->Scale( GLOB_FRM, nSpanU / dScaleU, nSpanV / dScaleV, 1) ;
if ( pSfrTrim != nullptr)
delete pSfrTrim ;
if ( bRev)
pSurfBezNew->Invert() ;
pSurfBezNew->RemoveCollapsedSpans() ;
pSurfBezNew->LimitSurfToTrimmedRegion() ;
#if SAVEREVOLVESURF
SaveGeoObj( pSurfBezNew->Clone(), "D:\\Temp\\bezier\\import3dm\\revolve_surf\\surf_ok.nge") ;
#endif
if ( ! bForceTriMesh)
vSurf.emplace_back( Release( pSurfBezNew)) ;
else
stmSoup.AddSurfTriMesh( *(pSurfBezNew->GetAuxSurf())) ;
}
else {
++nFailedBz ;
}
}
}
}
if ( nFailedBFace != 0) {
string sOut = "Import3dm : Failed conversion of " + to_string( nFailedBFace) + " Brep faces" ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
}
if ( nFailedTm != 0) {
string sOut = "Import3dm : Failed conversion of " + to_string( nFailedTm) + " trimesh belonging to a Brep" ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
}
if ( nFailedFr != 0) {
string sOut = "Import3dm : Failed conversion of " + to_string( nFailedFr) + " FlatRegion belonging to a Brep" ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
}
if ( nFailedBz != 0) {
string sOut = "Import3dm : Failed conversion of " + to_string( nFailedBz) + " NURBS belonging to a Brep" ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
}
if ( nFailedBTrim != 0) {
string sOut = "Import3dm : Failed conversion of " + to_string( nFailedBTrim) + " trims of surfaces belonging to a Brep" ;
LOG_ERROR( GetEE3Logger(), sOut.c_str()) ;
}
if ( ! stmSoup.End())
return vSurf ;
PtrOwner<ISurfTriMesh> pSTM( stmSoup.GetSurf()) ;
if ( ! IsNull( pSTM) && pSTM->IsValid())
vSurf.emplace_back( Release( pSTM)) ;
return vSurf ;
}
//----------------------------------------------------------------------------
ICurveComposite*
Import3dm::ApproxTrim( ICurve* pCrv)
{
PtrOwner<ICurveComposite> pCC( CreateCurveComposite()) ;
PolyLine plApprox ;
pCrv->ApproxWithLines(LIN_TOL_FINE, ANG_TOL_FINE, 0, plApprox) ;
pCC->FromPolyLine(plApprox) ;
pCC->MergeCurves(LIN_TOL_FINE, ANG_TOL_FINE) ;
return Release( pCC) ;
}
//----------------------------------------------------------------------------
ICurve*
Import3dm::ConvertBrepLoop( const ON_BrepLoop* onBrepLoop)
{
int nTrim = onBrepLoop->TrimCount() ;
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
if ( IsNull( pCrvCompo))
return nullptr ;
for ( int i = 0 ; i < nTrim ; ++i) {
ON_BrepTrim* onBrepTrim = onBrepLoop->Trim( i) ;
ON_CurveProxy* onCurveProxy = ON_CurveProxy::Cast( onBrepTrim);
PtrOwner<ICurve> pCrv( ConvertCurve( onCurveProxy)) ;
if ( IsNull(pCrv) || ! pCrv->IsValid())
continue ;
if ( ! pCrvCompo->AddCurve( pCrv->Clone())) {
Point3d ptEnd ; pCrvCompo->GetEndPoint( ptEnd) ;
pCrv->ModifyStart( ptEnd) ;
if ( ! pCrvCompo->AddCurve( pCrv->Clone()))
return nullptr ;
}
}
//// APPROSSIMO I BREP LOOP PER ALLEGGERIRE LE OPERAZIONI DI TRIM DELLE BEZIER
//pCrvCompo->RemoveSmallParts( 0.1, 15) ;
//pCrvCompo->MergeCurves( 0.1, 15) ;
//PolyArc paApprox ;
//pCrvCompo->ApproxWithArcs( 0.1, 15, paApprox) ;
//pCrvCompo->FromPolyArc( paApprox) ;
return Release( pCrvCompo) ;
}
//----------------------------------------------------------------------------
ISURFPOVECTOR
Import3dm::ConvertExtrusion( const ON_Extrusion* onExtrusion)
{
ISURFPOVECTOR vpSurf ;
Point3d ptStart( ConvertPoint( onExtrusion->PathStart())) ;
Point3d ptEnd( ConvertPoint( onExtrusion->PathEnd())) ;
Vector3d vtDir = ptEnd - ptStart ;
int nIsCapped = onExtrusion->IsCapped() ; // 0: no or profile is open /1: bottom cap( ptEnd) /2: top cap( ptStart) /3: both ends capped.
// creo la superficie a partire dalle curve
CICURVEPVECTOR vCrvProfile ;
int nProfiles = onExtrusion->ProfileCount() ;
////////// versione con le curve 2d da trasformare in 3d ( a volte manca un pezzo di trasformazione)
//ON_SimpleArray<const ON_Curve*> onSaProfile ;
//int nProfiles = onExtrusion->GetProfileCurves( onSaProfile) ;
for ( int i = 0 ; i < nProfiles ; ++i ) {
//const ON_Curve* onCurve = onSaProfile[i] ;
//ON_Xform onProfileFrame ; onExtrusion->GetProfileTransformation( 0, onProfileFrame) ;
//ON_Curve* onCurveCopy = onCurve->DuplicateCurve() ;
//onCurveCopy->Transform( onProfileFrame) ;
//PtrOwner<ICurve> pCurve( ConvertCurve( onCurveCopy)) ;
//delete onCurveCopy ;
ON_Curve* onCurve = onExtrusion->Profile3d( i, 0) ; // do per scontato che il profilo resti uguale dall'inizio alla fine del path
PtrOwner<ICurve> pCurve( ConvertCurve( onCurve)) ;
delete onCurve ;
if ( IsNull( pCurve) || ! pCurve->IsValid()) {
m_mError_count["extrusion"] += 1 ;
break ;
}
vCrvProfile.emplace_back( Release(pCurve)) ;
}
// uso l'estrusione con le bezier
for ( int i = 0 ; i < ssize( vCrvProfile); ++i) {
PtrOwner<ISurfBezier> pSurfBez( CreateSurfBezier()) ;
pSurfBez->CreateByExtrusion( vCrvProfile[i], vtDir) ;
vpSurf.emplace_back() ;
vpSurf.back().Set( Release( pSurfBez)) ;
}
///// quando ci saranno le surf compo allora la superficie con cap dovrà essere un'unica surfcompo
if ( nIsCapped != 0) {
// aggiungo anche le due superfici di cap
PtrOwner<ISurfBezier> pSurfBezCap( CreateSurfBezier()) ;
POLYLINEVECTOR vPL ;
for ( int i = 0 ; i < ssize( vCrvProfile) ; ++i) {
vPL.emplace_back() ;
vCrvProfile[i]->ApproxWithLines( LIN_TOL_STD, ANG_TOL_FINE, ICurve::ApprLineType::APL_STD, vPL.back()) ;
}
if ( nIsCapped == 2 || nIsCapped == 3) { // top o entrambe
if ( ! pSurfBezCap->CreateByRegion( vPL) || ! pSurfBezCap->Invert()) {
m_mError_count["extrusion"] += 1 ;
goto exit ;
}
vpSurf.emplace_back() ;
vpSurf.back().Set( Release( pSurfBezCap)) ;
}
if ( nIsCapped == 1 || nIsCapped == 3) { // bottom o entrambe
if ( nIsCapped == 3) {
vpSurf.emplace_back( vpSurf.back()->Clone()) ;
vpSurf.back()->Invert() ;
}
else {
pSurfBezCap.Set( CreateSurfBezier()) ;
if( ! pSurfBezCap->CreateByRegion( vPL)) {
m_mError_count["extrusion"] += 1 ;
goto exit ;
}
vpSurf.emplace_back() ;
vpSurf.back().Set( Release( pSurfBezCap)) ;
}
vpSurf.back()->Translate( vtDir) ;
}
}
// se ho fallito con le bezier procedo con le trimesh
if( ssize( vpSurf) == 0) {
if ( nIsCapped == 3) {
vpSurf.emplace_back( GetSurfTriMeshByRegionExtrusion( vCrvProfile, vtDir)) ;
}
else {
StmFromTriangleSoup stmSoup ;
if ( ! stmSoup.Start()) {
m_mError_count["extrusion"] += 1 ;
goto exit ;
}
for ( int i = 0 ; i < (int)vCrvProfile.size() ; ++i )
stmSoup.AddSurfTriMesh( *GetSurfTriMeshByExtrusion( vCrvProfile[i], vtDir, false)) ;
// controllo se la superficie è capped solo sopra o sotto ed eventualmente aggiungo alla trimesh la superficie adeguata
if ( nIsCapped != 0) {
PtrOwner<ISurfTriMesh> pSurfTmCap( GetSurfTriMeshByRegion( vCrvProfile)) ;
if ( ! IsNull( pSurfTmCap) && pSurfTmCap->IsValid()) {
// se capped sopra traslo la trimeshregion
if ( nIsCapped == 1)
pSurfTmCap->Translate(vtDir) ;
// sennò la aggiungo direttamente
stmSoup.AddSurfTriMesh( *pSurfTmCap) ;
}
}
if ( ! stmSoup.End()){
m_mError_count["extrusion"] += 1 ;
goto exit ;
}
vpSurf.emplace_back( GetSurfTriMesh( stmSoup.GetSurf())) ;
}
}
exit :
for ( int k = 0 ; k < (int)vCrvProfile.size() ; ++k) {
if ( vCrvProfile[k] != nullptr)
delete vCrvProfile[k] ;
}
return vpSurf ;
////////////////// VERSIONE CON BREP - RIDONDANTE
//if ( ! IsNull( pSurfTm) && pSurfTm->IsValid())
// return Release( pSurfTm) ;
//else {
// // se non sono riuscito a creare la superficie per qualche motivo, allora tento una conversione con gli strumenti di OPENURBS prima
// // di convertire la superficie
// //// CONVERSIONE DELL'EXTRUSION AD UN'ALTRA SUPERFICIE RHINO PRIMA DI ESSERE CONVERTITA
// ON_Object* onObject = nullptr ;
// ISurf* pSurf = nullptr ;
// PtrOwner<ISurfBezier> pSurfBz( CreateSurfBezier()) ;
// if ( IsNull( pSurfBz))
// return nullptr ;
// PtrOwner<ISurfTriMesh> pSurfTm( CreateSurfTriMesh()) ;
// if ( IsNull( pSurfTm))
// return nullptr ;
// if ( onExtrusion->IsCapped() || onExtrusion->ProfileCount() >= 2) {
// onObject = onExtrusion->BrepForm(0) ;
// if ( nullptr != onObject) {
// const ON_Brep* onBrep = ON_Brep::Cast( onObject) ;
// ISURFPOVECTOR vpSurf ;
// vpSurf = ConvertBrep( onBrep, true) ; // chiedo di ottenere un'unica superficie trimesh
// pSurfTm.Set( GetSurfTriMesh( Release(vpSurf[0]))) ;
// }
// }
// if ( onObject == nullptr) {
// onObject = onExtrusion->SumSurfaceForm(0) ;
// if ( onObject != nullptr) {
// const ON_Surface* onSurface = ON_Surface::Cast( onObject) ;
// pSurf = ConvertSurface( onSurface) ;
// pSurfTm.Set( GetSurfTriMesh(pSurf)) ;
// }
// }
// if ( onObject == nullptr) {
// onObject = onExtrusion->NurbsSurface(0) ;
// if ( onObject != nullptr) {
// const ON_NurbsSurface* onNurbsSurface = ON_NurbsSurface::Cast( onObject) ;
// pSurf = ConvertSurface( onNurbsSurface) ;
// // in questo caso devo anche trasformare la superficie di bezier che ho appenta ottenuto in una trimesh
// pSurfBz.Set( GetSurfBezier( pSurf)) ;
// pSurfTm.Set( pSurfBz->GetAuxSurf()->Clone()) ;
// }
// }
// if ( ! IsNull( pSurfTm) && pSurfTm->IsValid())
// return Release( pSurfTm) ;
//}
//m_mError_count["extrusion"] += 1 ;
//return nullptr ;
}
//----------------------------------------------------------------------------
ISurfTriMesh*
Import3dm::ConvertMesh( const ON_Mesh* onMesh)
{
ON_Mesh* onMeshToConvert = onMesh->Duplicate() ;
PtrOwner<ISurfTriMesh> pSurfTm( CreateSurfTriMesh()) ;
if ( IsNull( pSurfTm))
return nullptr ;
int nVertices = onMesh->VertexCount() ;
bool bDoublePrec = onMesh->HasDoublePrecisionVertices() ;
for ( int i = 0 ; i < nVertices ; ++i ) {
Point3d pt = ConvertPoint( bDoublePrec ? *( onMesh->m_dV.At( i)) : *( onMesh->m_V.At( i))) ;
pSurfTm->AddVertex( pt) ;
}
ON_MeshFaceList onFaceList( onMesh) ;
int nQuads = onMesh->QuadCount() ;
//split_method - [in]
// 0 default - Currently divides along the short diagonal.
// 1 divide along the short diagonal
// 2 divide along the long diagonal
// 3 minimize resulting area
// 4 maximize resulting area
// 5 minimize angle between triangle normals
// 6 maximize angle between triangle normals
double dLinTol = ON_UNSET_VALUE ;
double dAndTolRad = ON_UNSET_VALUE ;
unsigned int nSplitMethod = 0 ;
bool bStillQuads = false ;
if ( nQuads != 0) {
// restituisce il numero di quadrati convertiti
unsigned int nQuadsNonPlanarConv = onMeshToConvert->ConvertNonPlanarQuadsToTriangles( dLinTol, dAndTolRad, nSplitMethod) ;
bStillQuads = nQuadsNonPlanarConv == 0 ? true : false ;
}
int nFaces = onMeshToConvert->FaceCount() ;
for (int j = 0 ; j < nFaces ; ++j) {
const ON_MeshFace* onMeshFace = onMeshToConvert->m_F.At( j) ;
if ( ! bStillQuads ) {
int nIdVert[3] = {onMeshFace->vi[0], onMeshFace->vi[1],onMeshFace->vi[2]} ;
pSurfTm->AddTriangle( nIdVert) ;
}
else if ( onFaceList.IsQuad( j)) {
// la divisione automatica non è riuscita.
// divido lungo la diagonale più corta
Point3d pt0 = ConvertPoint( *onMesh->m_V.At(onMeshFace->vi[0])) ;
Point3d pt1 = ConvertPoint( *onMesh->m_V.At(onMeshFace->vi[1])) ;
Point3d pt2 = ConvertPoint( *onMesh->m_V.At(onMeshFace->vi[2])) ;
Point3d pt3 = ConvertPoint( *onMesh->m_V.At(onMeshFace->vi[3])) ;
if ( Dist( pt0, pt2) < Dist( pt1, pt3)) {
int nIdVert[3] = {onMeshFace->vi[0], onMeshFace->vi[1],onMeshFace->vi[2]} ;
pSurfTm->AddTriangle( nIdVert) ;
int nIdVert2[3] = {onMeshFace->vi[0], onMeshFace->vi[2],onMeshFace->vi[3]} ;
pSurfTm->AddTriangle( nIdVert2) ;
}
else {
int nIdVert[3] = {onMeshFace->vi[0], onMeshFace->vi[1],onMeshFace->vi[3]} ;
pSurfTm->AddTriangle( nIdVert) ;
int nIdVert2[3] = {onMeshFace->vi[1], onMeshFace->vi[2],onMeshFace->vi[3]} ;
pSurfTm->AddTriangle( nIdVert2) ;
}
}
}
delete onMeshToConvert ;
pSurfTm->AdjustTopology() ;
return Release( pSurfTm) ;
}
//----------------------------------------------------------------------------
std::vector<PtrOwner<IGeoObj>>
Import3dm::ConvertAnnotation( const ON_Annotation* onAnnot, const ON_DimStyle* onDimStyle)
{
// TO DO
// la posizione è da correggere se le annotazioni sono presenti nell'anteprima di stampa
// ( dovrebbe esserci nel modello un oggetto detail che ne definisce l'impaginazione)
vector<PtrOwner<IGeoObj>> vpObj ;
ON::AnnotationType onAnnType = onAnnot->Type() ;
switch( onAnnType) {
case ON::AnnotationType::Text : {
const ON_Text* onText = ON_Text::Cast( onAnnot) ;
string str = ConvertONwStringToString( onText->PlainText()) ;
ON_Plane onPlane = onText->Plane() ;
Point3d ptOrig = ConvertPoint( onPlane.origin) ;
Vector3d vtN = ConvertVector( onPlane.Normal()) ;
Vector3d vtDir = ConvertVector( onText->HorizontalDirection()) ;
PtrOwner<IExtText> tText( CreateExtText()) ;
tText->Set( ptOrig, vtN, vtDir, str, m_sFont, false, m_dTextHeight) ;
if ( ! IsNull( tText) && tText->IsValid()) {
vpObj.emplace_back( Release( tText)) ;
return vpObj ;
}
else
m_mError_count["annotation"] += 1 ;
break ;
}
case ON::AnnotationType::Leader : {
const ON_Leader* onLeader = ON_Leader::Cast( onAnnot) ;
string str = ConvertONwStringToString( onLeader->PlainText()) ;
ON_Plane onPlane = onAnnot->Plane() ;
Point3d ptOrig = ConvertPoint( onPlane.origin) ;
Vector3d vtX = ConvertVector( onPlane.xaxis) ;
Vector3d vtY = ConvertVector( onPlane.yaxis) ;
Vector3d vtN = ConvertVector( onPlane.Normal()) ;
Vector3d vtDir = ConvertVector( onAnnot->HorizontalDirection()) ;
ON_2dPoint on2dPoint ;
double dScale = onLeader->DimScale( onDimStyle) ;
onLeader->GetTextPoint2d( onDimStyle, dScale, on2dPoint) ;
Point3d ptTextPoint( on2dPoint.x, on2dPoint.y) ;
Frame3d frPlane ;
frPlane.Set( ptOrig, vtX, vtY,vtN) ;
ptTextPoint.ToGlob( frPlane) ;
PtrOwner<IExtText> tText( CreateExtText()) ;
tText->Set( ptTextPoint, vtN, vtDir, str, m_sFont, false, m_dTextHeight) ;
//aggiungo al gruppo: testo, linea e landing
if ( ! IsNull( tText) && tText->IsValid())
vpObj.emplace_back( Release( tText)) ;
else{
m_mError_count["annotation"] += 1 ;
break ;
}
const ON_Curve* onCurve = onLeader->Curve( onDimStyle) ;
PtrOwner<ICurve> pCurve( ConvertCurve( onCurve)) ;
if ( ! IsNull( pCurve) && pCurve->IsValid()) {
vpObj.emplace_back( Release( pCurve)) ;
}
else {
m_mError_count["annotation"] += 1 ;
vpObj.clear() ;
break ;
}
if ( onLeader->LeaderHasLanding( onDimStyle)) {
ON_Line onLine ;
onLeader->LandingLine2d( onDimStyle, dScale, onLine) ;
Point3d ptStart = ConvertPoint(onLine.from) ;
Point3d ptEnd = ConvertPoint(onLine.to) ;
PtrOwner<ICurveLine> pCrvL( CreateCurveLine()) ;
pCrvL->Set( ptStart, ptEnd) ;
if ( ! IsNull( pCrvL) && pCrvL->IsValid()) {
pCrvL->ToGlob( frPlane) ;
vpObj.emplace_back( Release( pCrvL)) ;
}
else {
m_mError_count["annotation"] += 1 ;
vpObj.clear() ;
break ;
}
}
break ;
}
case ON::AnnotationType::Aligned :
case ON::AnnotationType::Rotated : {
const ON_DimLinear* onDimLin = ON_DimLinear::Cast( onAnnot) ;
// recupero tutti i dati della quota
ON_3dPoint onPt1, onPt2, onPtAr1, onPtAr2, onPtDimLine, onPtText ;
onDimLin->Get3dPoints( &onPt1, &onPt2, &onPtAr1, &onPtAr2, &onPtDimLine, &onPtText) ;
double dAngDeg = onDimLin->TextRotationRadians() * RADTODEG ; // rotazione del testo rispetto alla direzione orizzontale
ON_Plane onPlane = onDimLin->Plane() ;
Vector3d vtN = ConvertVector( onPlane.Normal()) ;
Vector3d vtDir = ConvertPoint(onPt2) - ConvertPoint(onPt1) ;
if ( ! vtDir.Normalize() ||
! vtDir.Rotate( vtN, dAngDeg)) {
m_mError_count["annotation"] += 1 ;
break ;
}
Point3d ptP1( ConvertPoint( onPt1)) ;
Point3d ptP2( ConvertPoint( onPt2)) ;
Point3d ptPDimL( ConvertPoint( onPtDimLine)) ;
// creo la quota
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( onAnnType == ON::AnnotationType::Aligned) {
if ( IsNull( pDim ) ||
! pDim->SetStyle( m_dExtLine, m_dArrLen, m_dTextDist, m_bLenIsMM, m_nDecDig, m_sFont, m_dTextHeight) ||
! pDim->SetLinear( ptP1, ptP2, ptPDimL, vtN, V_NULL, "<>")) {
m_mError_count["annotation"] += 1 ;
break ;
}
}
else if ( onAnnType == ON::AnnotationType::Rotated){
if ( IsNull( pDim ) ||
! pDim->SetStyle( m_dExtLine, m_dArrLen, m_dTextDist, m_bLenIsMM, m_nDecDig, m_sFont, m_dTextHeight) ||
! pDim->SetLinear( ptP1, ptP2, ptPDimL, vtN, vtDir, "<>")) {
m_mError_count["annotation"] += 1 ;
break ;
}
}
// inserisco la quota nel DB
if ( ! IsNull( pDim) && pDim->IsValid()) {
vpObj.emplace_back( Release( pDim)) ;
return vpObj ;
}
else {
m_mError_count["annotation"] += 1 ;
break ;
}
}
case ON::AnnotationType::Angular :
case ON::AnnotationType::Angular3pt : {
// recupero tutti i dati della quota
const ON_DimAngular* onDimAng = ON_DimAngular::Cast( onAnnot) ;
ON_3dPoint onPtCen, onPt1, onPt2, onPtAr1, onPtAr2, onPtDimLine, onPtText ;
onDimAng->Get3dPoints( &onPtCen, &onPt1, &onPt2, &onPtAr1, &onPtAr2, &onPtDimLine, &onPtText) ;
ON_Plane onPlane = onDimAng->Plane() ;
Vector3d vtN = ConvertVector( onPlane.Normal()) ;
Point3d ptCen( ConvertPoint( onPtCen)) ;
Point3d ptP1( ConvertPoint( onPt1)) ;
Point3d ptP2( ConvertPoint( onPt2)) ;
Point3d ptPDimL( ConvertPoint( onPtDimLine)) ;
// creo la quota
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( ! IsNull( pDim) &&
pDim->SetStyle( m_dExtLine, m_dArrLen, m_dTextDist, m_bLenIsMM, m_nDecDig, m_sFont, m_dTextHeight) &&
pDim->SetAngular( ptCen, ptP1, ptP2, ptPDimL, vtN, "<>") &&
pDim->IsValid()) {
vpObj.emplace_back( Release( pDim)) ;
return vpObj ;
}
else {
m_mError_count["annotation"] += 1 ;
break ;
}
}
case ON::AnnotationType::Radius : {
const ON_DimRadial* onDimRad = ON_DimRadial::Cast( onAnnot) ;
ON_3dPoint onPtCen, onPt1, onPt2, onPtDim ;
onDimRad->Get3dPoints( &onPtCen, &onPtDim, &onPt1, &onPt2) ;
ON_Plane onPlane = onDimRad->Plane() ;
Vector3d vtN = ConvertVector( onPlane.Normal()) ;
Point3d ptCen( ConvertPoint( onPtCen)) ;
Point3d ptDim( ConvertPoint( onPtDim)) ;
// creo la quota
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( ! IsNull( pDim ) &&
pDim->SetStyle( m_dExtLine, m_dArrLen, m_dTextDist, m_bLenIsMM, m_nDecDig, m_sFont, m_dTextHeight) &&
pDim->SetRadial( ptCen, ptDim, vtN, "<>")) {
vpObj.emplace_back( Release( pDim)) ;
return vpObj ;
}
else {
m_mError_count["annotation"] += 1 ;
break ;
}
}
case ON::AnnotationType::Diameter : {
const ON_DimRadial* onDimRad = ON_DimRadial::Cast( onAnnot) ;
ON_3dPoint onPtCen, onPt1, onPt2, onPtDim ;
onDimRad->Get3dPoints( &onPtCen, &onPtDim, &onPt1, &onPt2) ;
ON_Plane onPlane = onDimRad->Plane() ;
Vector3d vtN = ConvertVector( onPlane.Normal()) ;
Point3d ptCen( ConvertPoint( onPtCen)) ;
Point3d ptDim( ConvertPoint( onPtDim)) ;
// creo la quota
PtrOwner<IExtDimension> pDim( CreateExtDimension()) ;
if ( ! IsNull( pDim ) ||
pDim->SetStyle( m_dExtLine, m_dArrLen, m_dTextDist, m_bLenIsMM, m_nDecDig, m_sFont, m_dTextHeight) ||
pDim->SetDiametral( ptCen, ptDim, vtN, "<>")) {
vpObj.emplace_back( Release( pDim)) ;
return vpObj ;
}
else {
m_mError_count["annotation"] += 1 ;
break ;
}
}
default :
m_mError_count["annotation"] += 1 ;
break ;
}
return vpObj ;
}
//----------------------------------------------------------------------------
bool
Import3dm::ConvertCurveParam( const ON_RevSurface* onRevSurf, ICurve** pCrv)
{
PtrOwner<ICurve> pCrvNew ;
if ( (*pCrv)->GetType() == CRV_LINE) {
PtrOwner<ICurveLine> pCrvLine( CreateCurveLine()) ;
double dnurbsU ;
double dnurbsV ;
Point3d ptStart ; (*pCrv)->GetStartPoint( ptStart) ;
onRevSurf->GetNurbFormParameterFromSurfaceParameter( ptStart.x, ptStart.y, &dnurbsU, &dnurbsV) ;
ptStart.Set( dnurbsU, dnurbsV, 0) ;
Point3d ptEnd ; (*pCrv)->GetEndPoint( ptEnd) ;
onRevSurf->GetNurbFormParameterFromSurfaceParameter( ptEnd.x, ptEnd.y, &dnurbsU, &dnurbsV) ;
ptEnd.Set( dnurbsU, dnurbsV, 0) ;
pCrvLine->Set( ptStart, ptEnd) ;
pCrvNew.Set( Release( pCrvLine)) ;
}
else if ( (*pCrv)->GetType() == CRV_ARC) {
double dnurbsU ;
double dnurbsV ;
Point3d ptStart ; (*pCrv)->GetStartPoint( ptStart) ;
onRevSurf->GetNurbFormParameterFromSurfaceParameter( ptStart.x, ptStart.y, &dnurbsU, &dnurbsV) ;
ptStart.Set( dnurbsU, dnurbsV, 0) ;
Point3d ptEnd ; (*pCrv)->GetEndPoint( ptEnd) ;
onRevSurf->GetNurbFormParameterFromSurfaceParameter( ptEnd.x, ptEnd.y, &dnurbsU, &dnurbsV) ;
ptEnd.Set( dnurbsU, dnurbsV, 0) ;
Vector3d vtDir, vtN ;
(*pCrv)->GetStartDir( vtDir) ;
ICurveArc* pCrvArcOrig = GetCurveArc( (*pCrv)) ;
vtN = pCrvArcOrig->GetNormVersor( ) ;
PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
pCrvArc->Set2PVN( ptStart, ptEnd, vtDir, vtN) ;
pCrvNew.Set( Release( pCrvArc)) ;
}
else if ( (*pCrv)->GetType() == CRV_BEZIER) {
double dnurbsU ;
double dnurbsV ;
PtrOwner<ICurveBezier> pCrvBez( GetCurveBezier( (*pCrv))) ;
int nDeg = pCrvBez->GetDegree() ;
int nCV = nDeg + 1 ;
for ( int i = 0 ; i < nCV ; ++i) {
Point3d ptNew = pCrvBez->GetControlPoint( i) ;
onRevSurf->GetNurbFormParameterFromSurfaceParameter( ptNew.x, ptNew.y, &dnurbsU, &dnurbsV) ;
ptNew.Set( dnurbsU, dnurbsV, 0) ;
// sto cambiando le coordinate dei CP nella curva, mentre i pesi non sono da modificare
pCrvBez->SetControlPoint( i, ptNew) ;
}
pCrvNew.Set( pCrvBez) ;
}
else if ( (*pCrv)->GetType() == CRV_COMPO) {
PtrOwner<ICurveComposite> pCrvCompo( GetCurveComposite( (*pCrv))) ;
PtrOwner<ICurveComposite> pCrvCompoNew( CreateCurveComposite()) ;
for ( const ICurve* pCrvSimpleOrig = pCrvCompo->GetFirstCurve() ; pCrvSimpleOrig != nullptr ; pCrvSimpleOrig = pCrvCompo->GetNextCurve()) {
ICurve* pCrvSimple( pCrvSimpleOrig->Clone()) ;
ConvertCurveParam( onRevSurf, &pCrvSimple) ;
pCrvCompoNew->AddCurve( pCrvSimple) ;
}
pCrvNew.Set( pCrvCompoNew) ;
}
(*pCrv) = Release( pCrvNew) ;
return true ;
}
Reference in New Issue View Git Blame Copy Permalink