Egalware/EgtExchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c5503427cba334131ff1001edd816fa7cdce0cc0
EgtExchange/Import3dm.cpp
T
Daniele Bariletti c5503427cb EgtExchange : 
- aggiunti oggetti all'import3dm e corretti alcuni bug.
2023-09-01 17:22:03 +02:00

946 lines
39 KiB
C++
Raw 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 "map"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/SELkKeyProc.h"
#include "/EgtDev/Include/EgtKeyCodes.h"
#include "/EgtDev/Include/EgtPointerOwner.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/EGkSurfAux.h"
#include "/EgtDev/Include/EGkStmFromCurves.h"
#include "/EgtDev/Include/EGkSurfFlatRegion.h"
#include "/EgtDev/Include/EGkSurfBezier.h"
#include "/EgtDev/Include/EGkSurf.h"
#include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
#include "/EgtDev/Include/EGkSfrCreate.h"
#include "/EgtDev/Include/EXeConst.h"
#include "C:/EgtDev/opennurbs/opennurbs.h"
using namespace std ;
//----------------------------------------------------------------------------
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) ;
}
//----------------------------------------------------------------------------
bool
Import3dm::Import( const string& sFile__, IGeomDB* pGDB, int nIdGroup, double dScaleFactor)
{
// verifico il DB geometrico
if ( pGDB == nullptr) {
LOG_ERROR( GetEExLogger(), "Import3dm : Error on GeomDB")
return false ;
}
m_pGDB = pGDB ;
// verifico l'Id di gruppo
if ( ! m_pGDB->ExistsObj( nIdGroup)) {
LOG_ERROR( GetEExLogger(), "Import3dm : Error on IdGroup")
return false ;
}
m_nIdGroup = nIdGroup ;
// verifico il fattore di scala
if ( dScaleFactor < EPS_SMALL) {
LOG_ERROR( GetEExLogger(), "Import3dm : Error on ScaleFactor too small (minimum 0.001).")
return false ;
}
m_dScaleFactor = dScaleFactor ;
// scorro l'archivio fino ad arrivare agli elementi geometrici
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V6\\my_points.3dm" ; // ok
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V6\\my_curves.3dm" ; // ok
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V7\\v7_my_surfaces.3dm" ; // ok
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V6\\my_surfaces.3dm" ; // file vuoto!!!!!!!!!!!!!!
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V7\\v7_rhino_logo_subd.3dm" ; // non si convertono e non le gestiamo
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V7\\v7_my_mesh.3dm" ; // ok
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V7\\v7_my_mesh_with_material.3dm" ; // ok
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V7\\v7_my_brep.3dm" ; // ok
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V5\\v5_example_file.3dm" ;
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V5\\v5_rhino_logo.3dm" ;
//std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V7\\v7_rhino_logo_nurbs.3dm" ;
std::string sFile = "C:\\EgtDev\\opennurbs\\example_files\\V5\\v5_my_trimmed_surface.3dm" ;
ONX_Model model;
std::wstring widestr = std::wstring(sFile.begin(), sFile.end()) ;
const wchar_t* sFileName = widestr.c_str() ;
FILE* archive_fp = ON::OpenFile( sFileName, L"rb") ;
if ( !archive_fp )
{
LOG_ERROR( GetEExLogger(), "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 = model.Read( archive, &dump ) ;
if ( ! rc)
LOG_ERROR( GetEExLogger(), "Unable to read file." ) ;
// close the file
ON::CloseFile( archive_fp ) ;
// conto il numero di layer e li creo
//model.Internal_ComponentListConst(ON_ModelComponent::Type::Layer).m_count
ON_ModelComponent::Type component_type_l = ON_ModelComponent::Type::Layer ;
ONX_ModelComponentIterator component_iterator_l ( model, ON_ModelComponent::Type::Layer) ;
int nLayer = 0 ;
m_pGDB->Erase( 2) ;
for( const ON_ModelComponent* mc = component_iterator_l.FirstComponent() ; nullptr != mc ; mc = component_iterator_l.NextComponent()) {
++nLayer ;
m_pGDB->AddGroup( GDB_ID_NULL, 1, GLOB_FRM) ;
}
ON_ModelComponent::Type component_type = ON_ModelComponent::Type::ModelGeometry ;
ONX_ModelComponentIterator component_iterator ( 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
map< string, int> error_count ;
int nId, nCount = 0 ;
for( const ON_ModelComponent* mc = component_iterator.FirstComponent() ; nullptr != mc ; mc = component_iterator.NextComponent()) {
const ON_ModelGeometryComponent* mgc = ON_ModelGeometryComponent::Cast( mc) ;
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 ;
if ( nLayer < 0)
nLayer = 2 ;
else
nLayer = nLayer + 2 ;
// recupero il colore dell'oggetto
Color cCol ;
ON_Color onCol = attributes->m_color ;
//cCol.Set( onCol.Red(), onCol.Green(), onCol.Blue(), int(onCol.Alpha()/2.55)) ;
cCol.Set( onCol.Red(), onCol.Green(), onCol.Blue(), 100) ;
// converto l'oggetto e lo aggiungo al GeomDB
ON::object_type type = oGeometry->ObjectType() ;
++nCount ;
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()) ;
pGeoPnt->Set( pt) ;
if ( ! IsNull( pGeoPnt) && pGeoPnt->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, Release(pGeoPnt)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_count["point"] += 1 ;
break ;
}
case ON::object_type::pointset_object : {
const ON_PointCloud* pc = ON_PointCloud::Cast( oGeometry);
if ( nullptr == pc ) {
error_count["pointset"] += 1 ;
break ;
}
int count = pc->PointCount() ;
Frame3d frLayer = m_pGDB->GetGroupFrame( nLayer) ;
int nSubLayer = m_pGDB->AddGroup( GDB_ID_NULL, nLayer, frLayer) ;
for ( int i = 0; i < count ; i++ ) {
Point3d pt( ConvertPoint( pc->m_P[i])) ;
// lo aggiungo al GeomDB nel layer corretto
PtrOwner<IGeoPoint3d> pGeoPnt( CreateGeoPoint3d()) ;
pGeoPnt->Set( pt) ;
if ( ! IsNull( pGeoPnt) && pGeoPnt->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nSubLayer, Release(pGeoPnt)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_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()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, Release( pCurve)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_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() ) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, Release( pSurf)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_count["surface"] += 1 ;
break ;
}
case ON::object_type::brep_object : {
const ON_Brep* onBrep = ON_Brep::Cast( oGeometry) ;
ISURFPVECTOR vpSurf = ConvertBrep( onBrep, false) ;
for (int k = 0 ; k < int( vpSurf.size()) ; ++k) {
if ( vpSurf[k]->GetType() == SRF_TRIMESH) {
PtrOwner<ISurfTriMesh> pSurfTm( GetSurfTriMesh( vpSurf[k])) ;
if ( ! IsNull( pSurfTm) && pSurfTm->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, Release(pSurfTm)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_count["brep"] += 1 ;
}
else if ( vpSurf[k]->GetType() == SRF_BEZIER ) {
PtrOwner<ISurfBezier> pSurfBz( GetSurfBezier( vpSurf[k])) ;
if ( ! IsNull( pSurfBz) && pSurfBz->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, Release(pSurfBz)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_count["brep"] += 1 ;
}
}
break ;
}
case ON::object_type::extrusion_object : {
const ON_Extrusion* onExtrusion = ON_Extrusion::Cast( oGeometry) ;
Point3d ptStart( ConvertPoint( onExtrusion->PathStart())) ;
Point3d ptEnd( ConvertPoint( onExtrusion->PathEnd())) ;
//int nProfiles = onExtrusion->ProfileCount() ;
ON_SimpleArray<const ON_Curve*> onSaProfile ;
int nProfiles = onExtrusion->GetProfileCurves( onSaProfile) ;
Vector3d vDir = ptEnd - ptStart ;
int nIsCapped = onExtrusion->IsCapped() ; // 0: no or profile is open /1: bottom cap /2: top cap /3: both ends capped.
PtrOwner<ISurfTriMesh> pSurfTm( CreateSurfTriMesh()) ;
StmFromTriangleSoup stmSoup ;
if ( ! stmSoup.Start())
return nullptr ;
if ( IsNull(pSurfTm) ) {
error_count["memory"] += 1 ;
break ;
}
// creo la superficie a partire dalle curve
if ( nIsCapped == 0) {
for (int i = 0 ; i < nProfiles ; ++i ) {
const ON_Curve* onCurve = onSaProfile[i] ;
ICurve* pCurve = nullptr ;
pCurve = ConvertCurve( onCurve) ;
stmSoup.AddSurfTriMesh( *GetSurfTriMeshByExtrusion( pCurve, vDir, false)) ;
}
}
// se capped
else {
CICURVEPVECTOR vCrvProfile ;
for (int i = 0 ; i < nProfiles ; ++i ) {
const ON_Curve* onCurve = onSaProfile[i] ;
PtrOwner<ICurve> pCurve( ConvertCurve( onCurve)) ;
vCrvProfile.push_back( Release(pCurve)) ;
}
// se l'estrusione è capped sia sopra che sotto uso la funzione *byRegionExtrusion
if ( nIsCapped == 3) {
pSurfTm.Set( GetSurfTriMeshByRegionExtrusion( vCrvProfile, vDir)) ;
}
// controllo se la superficie è capped solo sopra o sotto ed eventualmente aggiungo alla trimesh la superficie adeguata
else {
for (int i = 0 ; i < nProfiles ; ++i ) {
PtrOwner<const ICurve> pCurveToAdd( vCrvProfile[i]) ;
stmSoup.AddSurfTriMesh( *GetSurfTriMeshByExtrusion( Release( pCurveToAdd), vDir, false)) ;
}
if ( nIsCapped == 1) {
stmSoup.AddSurfTriMesh( *GetSurfTriMeshByRegion( vCrvProfile)) ;
}
else if ( nIsCapped == 2 ) {
PtrOwner<ISurfTriMesh> pSurfTmCap( GetSurfTriMeshByRegion( vCrvProfile)) ;
pSurfTmCap->Translate(vDir) ;
stmSoup.AddSurfTriMesh( *Release(pSurfTmCap)) ;
}
}
}
if ( ! stmSoup.End())
return nullptr ;
if ( nIsCapped == 1 || nIsCapped == 2)
pSurfTm.Set( GetSurfTriMesh( stmSoup.GetSurf())) ;
if ( ! IsNull( pSurfTm) && pSurfTm->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, Release( pSurfTm)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
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<const ISurfBezier> pSurfBz( CreateSurfBezier()) ;
PtrOwner<const ISurfTriMesh> pSurfTm( CreateSurfTriMesh()) ;
if ( onExtrusion->IsCapped() || onExtrusion->ProfileCount() >= 2) {
onObject = onExtrusion->BrepForm(0) ;
if ( nullptr != onObject) {
const ON_Brep* onBrep = ON_Brep::Cast( onObject) ;
ISURFPVECTOR vpSurf ;
vpSurf = ConvertBrep( onBrep, true) ; // chiedo di ottenere un'unica superficie trimesh
pSurfTm.Set( static_cast<ISurfTriMesh*>( vpSurf[0])) ;
}
}
if ( nullptr == onObject) {
onObject = onExtrusion->SumSurfaceForm(0) ;
if ( nullptr != onObject) {
const ON_Surface* onSurface = ON_Surface::Cast( onObject) ;
pSurf = ConvertSurface( onSurface) ;
pSurfTm.Set( static_cast<ISurfTriMesh*>(pSurf)) ;
}
}
if ( nullptr == onObject) {
onObject = onExtrusion->NurbsSurface(0) ;
if ( nullptr != onObject) {
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( static_cast<ISurfBezier*>( pSurf)) ;
pSurfTm.Set( pSurfBz->GetAuxSurf()) ;
}
}
if ( ! IsNull( pSurfTm) && pSurfTm->IsValid()) {
nId = m_pGDB->AddGeoObj( GDB_ID_NULL, nLayer, pSurfTm->Clone()) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_count["extrusion"] += 1 ;
}
break ;
}
case ON::object_type::mesh_object :{
const ON_Mesh* onMesh = ON_Mesh::Cast( oGeometry) ;
ON_Mesh* onMeshToConvert = onMesh->Duplicate() ;
PtrOwner<ISurfTriMesh> pSurfTm( CreateSurfTriMesh()) ;
double x = onMesh->m_V.At( 0)->x ;
if ( IsNull( pSurfTm)) {
error_count["memory"] += 1 ;
break ;
}
int nVertices = onMesh->VertexCount() ;
bool bDoublePrec = onMesh->HasDoublePrecisionVertices() ;
if ( bDoublePrec) {
for ( int i = 0 ; i < nVertices ; ++i ) {
Point3d pt = ConvertPoint( *(onMesh->m_dV.At(i)));
pSurfTm->AddVertex( pt) ;
}
}
else {
for ( int i = 0 ; i < nVertices ; ++i ) {
Point3d pt = ConvertPoint( *(onMesh->m_V.At(i)));
pSurfTm->AddVertex( pt) ;
}
}
ON_MeshFaceList onFaceList( onMesh) ;
//int nFaces = onMesh->FaceCount() ;
int nQuads = onMesh->QuadCount() ;
//int nTrias = onMesh->TriangleCount();
//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() ;
//nQuads = onMeshToConvert->QuadCount() ;
int nTrias = onMeshToConvert->TriangleCount();
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_dV.At(onMeshFace->vi[0])) ;
Point3d pt1 = ConvertPoint( *onMesh->m_dV.At(onMeshFace->vi[1])) ;
Point3d pt2 = ConvertPoint( *onMesh->m_dV.At(onMeshFace->vi[2])) ;
Point3d pt3 = ConvertPoint( *onMesh->m_dV.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) ;
}
}
}
pSurfTm->AdjustTopology() ;
if ( ! IsNull( pSurfTm) && pSurfTm->IsValid()) {
nId = m_pGDB->AddGeoObj(GDB_ID_NULL, nLayer, Release( pSurfTm)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_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()) {
nId = m_pGDB->AddGeoObj(GDB_ID_NULL, nLayer, Release( pCurve)) ;
m_pGDB->SetMaterial( nId, cCol) ;
}
else
error_count["loop"] += 1 ;
break ;
}
case ON::object_type::subd_object: {
const ON_SubD* onSubD = ON_SubD::Cast( oGeometry) ;
// non c'è un comando per convertire le subd in altre superfici...
//ON_Surface* onSurface ; //= ON_Surface::Cast() ;
//PtrOwner<ISurf> pSurf( ConvertSurface( onSurface)) ;
//if ( ! IsNull( pSurf) && pSurf->IsValid())
// m_pGDB->AddGeoObj(GDB_ID_NULL, nLayer, Release( pSurf)) ;
//else
// error_count["subd"] += 1 ;
error_count["subd"] += 1 ;
break ;
}
case ON::object_type::annotation_object: {
const ON_Annotation* onAnnot = ON_Annotation::Cast( oGeometry) ;
ON_wString wsText = onAnnot->PlainText() ;
const wchar_t* wchar = wsText ;
std::wstring ws( wchar) ;
std::string str( ws.begin(), ws.end()) ;
LOG_ERROR( GetEExLogger(), str.c_str()) ;
break ;
}
default :
break ;
}
//if ( nCount > 19)
// break ;
}
// messaggio di errore da mettere nel log per dire quanti oggetti sono stati ignorati perché la conversione non è riuscita
map<string, int>::iterator it = error_count.begin() ;
while (it != error_count.end()) {
string type = it->first ;
int count = it->second ;
if ( type != "memory" ) {
string sOut = "Sono stati ignorati " + to_string( count) + " oggetti di tipo " + type ;
LOG_ERROR( GetEExLogger(), sOut.c_str()) ;
}
else {
string sOut = "Sono stati ignorati " + to_string( count) + " oggetti perché è finita la memoria" ;
LOG_ERROR( GetEExLogger(), sOut.c_str()) ;
}
it++;
}
return true ;
}
//----------------------------------------------------------------------------
Point3d
Import3dm::ConvertPoint( const ON_Point& onPoint)
{
double x = onPoint.point.x ;
double y = onPoint.point.y ;
double z = onPoint.point.z ;
// creo il punto nel nostro kernel
Point3d pt( x, y, z) ;
return pt ;
}
//----------------------------------------------------------------------------
Point3d
Import3dm::ConvertPoint( const ON_3dPoint& on3dPoint)
{
double x = on3dPoint.x ;
double y = on3dPoint.y ;
double z = on3dPoint.z ;
// creo il punto nel nostro kernel
Point3d pt( x, y, z) ;
return pt ;
}
//----------------------------------------------------------------------------
Point3d
Import3dm::ConvertPoint( const ON_4dPoint& on4dPoint)
{
double x = on4dPoint.x ;
double y = on4dPoint.y ;
double z = on4dPoint.z ;
// creo il punto nel nostro kernel
Point3d pt( x, y, z) ;
return pt ;
}
//----------------------------------------------------------------------------
Point3d
Import3dm::ConvertPoint( const ON_3fPoint& on3fPoint)
{
double x = on3fPoint.x ;
double y = on3fPoint.y ;
double z = on3fPoint.z ;
// creo il punto nel nostro kernel
Point3d pt( x, y, z) ;
return pt ;
}
//----------------------------------------------------------------------------
Vector3d
ConvertVector( const ON_3dVector& onVector)
{
Vector3d vt ;
vt.x = onVector.x ;
vt.y = onVector.y ;
vt.z = onVector.z ;
return vt ;
}
//----------------------------------------------------------------------------
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()))) ;
ON_3dVector on_vtN = onArc->m_arc.plane.zaxis ;
Vector3d vtN = ConvertVector( on_vtN) ;
ICurveArc* pCurveArc( CreateCurveArc()) ;
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 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() ;
ICurveArc* pCurveArc( CreateCurveArc()) ;
pCurveArc->Set( ptCenter, vtN, dRad) ;
return 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)) ;
ICurveLine* pCurveLine ( CreateCurveLine()) ;
pCurveLine->Set( ptStart, ptEnd) ;
return 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) ;
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 ;
}
// vettore dei nodi
DBLVECTOR vU ;
int nKnot = onNurbsCurve->KnotCount() ;
for ( int j = 0 ; j < nKnot ; ++j ) {
double nKnot = onNurbsCurve->Knot( j) ;
vU.push_back( nKnot) ;
}
nuCurve.vU = vU ;
nuCurve.bClosed = onNurbsCurve->IsClosed() ;
// dovrei aggiungere la gestione delle curve periodiche ( unclamped) in modo da poter importare anche le curve chiuse
nuCurve.bPeriodic = onNurbsCurve->IsPeriodic() ;
// 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
if ( nU == int( nuCurve.vU.size()) + 2)
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) ;
ON_Curve* onCurve = onProxyCurve->DuplicateCurve() ;
return ConvertCurve( onCurve) ;
break ;
}
case ON::eCurveType::ctPolycurve : {
const ON_PolyCurve* onPolyline = ON_PolyCurve::Cast( onCurve) ;
int nCurves = onPolyline->Count() ;
ICurveComposite* pCrvCompo( CreateCurveComposite()) ;
for ( int i = 0 ; i < nCurves; ++i) {
ICurve* pCurveToAdd = nullptr ;
ON_Curve* onCurveToAdd = onPolyline->SegmentCurve( i) ;
pCurveToAdd = ConvertCurve( onCurveToAdd) ;
pCrvCompo->AddCurve( pCurveToAdd) ;
}
return pCrvCompo ;
break ;
}
case ON::eCurveType::ctPolyline : {
const ON_PolylineCurve* onPolyline = ON_PolylineCurve::Cast( onCurve) ;
int nPoints = onPolyline->PointCount() ;
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) ;
ptNew = ptOld ;
}
return pCrvCompo ;
break ;
}
default :
break ;
}
return nullptr ;
}
//----------------------------------------------------------------------------
ISurf*
Import3dm::ConvertSurface( const ON_Surface* onSurf)
{
if ( const ON_NurbsSurface* onNurbsSurface = ON_NurbsSurface::Cast( onSurf)) {
CNurbsSurfData cNurbsSurf ;
cNurbsSurf.bClosedU = onNurbsSurface->IsClosed( 0) ;
cNurbsSurf.bClosedV = onNurbsSurface->IsClosed( 1) ;
cNurbsSurf.bPeriodicU = onNurbsSurface->IsPeriodic( 0) ;
cNurbsSurf.bPeriodicV = onNurbsSurface->IsPeriodic( 1) ;
cNurbsSurf.bRat = onNurbsSurface->IsRational() ;
cNurbsSurf.nDegU = onNurbsSurface->Degree( 0) ;
cNurbsSurf.nDegV = onNurbsSurface->Degree( 1) ;
cNurbsSurf.nCPU = onNurbsSurface->CVCount( 0) ;
cNurbsSurf.nCPV = onNurbsSurface->CVCount( 1) ;
vector<Point3d> vCPV( cNurbsSurf.nCPV) ;
cNurbsSurf.mCP.resize( cNurbsSurf.nCPU, vCPV) ;
DBLVECTOR vWV( cNurbsSurf.nCPV) ;
cNurbsSurf.mW.resize( cNurbsSurf.nCPU, vWV) ;
for ( int i = 0 ; i < cNurbsSurf.nCPU ; ++i) {
for ( int j = 0 ; j < cNurbsSurf.nCPV ; ++j) {
ON_4dPoint o4dPoint = onNurbsSurface->ControlPoint(i, j) ;
cNurbsSurf.mCP[i][j] = ConvertPoint( o4dPoint) ;
cNurbsSurf.mW[i][j] = o4dPoint.w ;
}
}
for ( int i = 0 ; i < onNurbsSurface->KnotCount(0) ; ++i ) {
cNurbsSurf.vU.push_back( onNurbsSurface->Knot( 0, i)) ;
}
for ( int j = 0 ; j < onNurbsSurface->KnotCount(1) ; ++j ) {
cNurbsSurf.vV.push_back( onNurbsSurface->Knot( 1, j)) ;
}
return NurbsToBezierSurface( cNurbsSurf) ;
}
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 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]) ;
Frame3d frPlane ;
frPlane.Set( ptOrig, vtZ) ;
pt0.ToGlob( frPlane) ;
pt1.ToGlob( frPlane) ;
pt2.ToGlob( frPlane) ;
pt3.ToGlob( frPlane) ;
// costruisco la figura e la inserisco nel GDB
PolyLine PL ;
PL.AddUPoint( 0, pt0) ;
PL.AddUPoint( 1, pt1) ;
PL.AddUPoint( 2, pt2) ;
PL.AddUPoint( 3, pt3) ;
PL.AddUPoint( 4, pt0) ;
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
pCrvCompo->FromPolyLine( PL) ;
PtrOwner<ISurfTriMesh> pSurf ( GetSurfTriMeshByFlatContour( Release(pCrvCompo))) ;
return Release( pSurf) ;
}
else if ( const ON_RevSurface* onRevSurface = ON_RevSurface::Cast( onSurf)) {
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 ;
PtrOwner<ISurfTriMesh> pSurf( CreateSurfTriMesh()) ;
// 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)) {
ON_NurbsSurface onNurbsSurface ;
// prima di usare la nurbs form tento di costruire la superficie con una rail ( funzione seguente)
//GetSurfTriMeshSwept
int bOk = onSumSurface->GetNurbForm( onNurbsSurface) ;
PtrOwner<ISurf> pSurf( ConvertSurface( &onNurbsSurface)) ;
if ( bOk != 0)
return Release( pSurf) ;
else {
// se fallisce questo tentativo di conversione allora recupero le curve e costruisco la superficie di Bezier
ON_Interval onIntDomain0 = onSumSurface->Domain(0) ;
ON_Interval onIntDomain1 = onSumSurface->Domain(1) ;
PtrOwner<ON_Curve> pCrvWest( onSumSurface->IsoCurve(1, onIntDomain0[0])) ;
PtrOwner<ON_Curve> pCrvEast( onSumSurface->IsoCurve(1, onIntDomain0[1])) ;
PtrOwner<ON_Curve> pCrvNorth( onSumSurface->IsoCurve(0, onIntDomain1[1])) ;
PtrOwner<ON_Curve> pCrvSouth( onSumSurface->IsoCurve(0, onIntDomain1[0])) ;
}
}
else if ( const ON_SurfaceProxy* onSurfaceProxy = ON_SurfaceProxy::Cast( onSurf)) {
PtrOwner<ISurf> pSurf ;
if ( const ON_BrepFace* onBrepFace = ON_BrepFace::Cast( onSurfaceProxy)) {
ON_NurbsSurface onNurbsSurface ;
int nOk = onBrepFace->GetNurbForm( onNurbsSurface) ;
if ( nOk != 0)
pSurf.Set( ConvertSurface( & onNurbsSurface)) ;
else
return nullptr ;
}
else if ( const ON_OffsetSurface* onOffsetSurface = ON_OffsetSurface::Cast( onSurfaceProxy)) {
pSurf.Set( ConvertSurface( onOffsetSurface->BaseSurface())) ;
}
else
pSurf.Set( ConvertSurface( onSurfaceProxy->DuplicateSurface())) ;
return Release( pSurf) ;
}
return nullptr ;
}
//----------------------------------------------------------------------------
ISURFPVECTOR
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
ISURFPVECTOR vSurf ;
//surfaces
int nSurf = onBrep->m_S.Count() ;
StmFromTriangleSoup stmSoup ;
if ( ! stmSoup.Start())
return vSurf ;
bool bSurfTm = false ;
for ( int i = 0 ; i < nSurf ; ++i) {
//ON_BrepFace* onBrepFace = onBrep->Face( i) ;
//onBrepFace->LoopCount() ;
ON_Surface* onSurface = onBrep->m_S[i] ;
ON_BrepFace* onFace = onBrep->Face( i) ;
int nLoop = onFace->LoopCount() ;
static bool bDone = false ;
//// da attivare per il debug del file V5/V5_example_file.3dm
//if ( ! bDone ) {
// // provo a replicare la nurbs a mano per vedere se esce il cerchio
// ON_BrepLoop* onLoop0 = onFace->Loop( 0) ;
// ON_BrepTrim* onBrepTrim = onLoop0->Trim( 0) ;
// ON_CurveProxy* onCurveProxy = ON_CurveProxy::Cast( onBrepTrim);
// ON_Curve* onCurve = onCurveProxy->DuplicateCurve() ;
// const ON_NurbsCurve* onNurbs = ON_NurbsCurve::Cast( onCurve) ;
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// int nMax = 4 ;
// for ( int k = 0 ; k < nMax; ++k) {
// ICurveBezier* crvBz( CreateCurveBezier()) ;
// crvBz->Init( onNurbs->Degree(), onNurbs->IsRational());
// int nCount = onNurbs->CVCount() ;
// if ( onNurbs->IsRational()) {
// for( int i = 0 ; i < 3; ++i) {
// ON_4dPoint o4dPoint ;
// onNurbs->GetCV( i + 2*k, o4dPoint) ;
// Point3d ptCtrl( ConvertPoint( o4dPoint)) ;
// crvBz->SetControlPoint( i, ptCtrl, o4dPoint.w) ;
// }
// }
// m_pGDB->AddGeoObj(GDB_ID_NULL, 0, crvBz) ;
// }
// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ICurve* pCurve0 = ConvertBrepLoop( onLoop0) ;
//
// m_pGDB->AddGeoObj(GDB_ID_NULL, 0, pCurve0) ;
// ON_BrepLoop* onLoop1 = onFace->Loop( 1) ;
// ICurve* pCurve1 = ConvertBrepLoop( onLoop1) ;
// m_pGDB->AddGeoObj(GDB_ID_NULL, 0, pCurve1) ;
// bDone = true ;
//}
PtrOwner<ISurf> pSurf( ConvertSurface( onSurface)) ;
if ( IsNull(pSurf)) {
string sOut = "Non è riuscita la conversione di " + to_string( nSurf - i) + " superfici appartenenti ad una Brep" ;
LOG_ERROR( GetEExLogger(), sOut.c_str()) ;
return vSurf ;
}
// se ho una trimesh la aggiungo, se è una bezier ricavo la trimesh prima di aggiungerla
int nType = pSurf->GetType() ;
if ( nType == SRF_TRIMESH ) {
bSurfTm = true ;
PtrOwner<ISurfTriMesh> pSurfTm ( GetSurfTriMesh( Release( pSurf))) ;
if ( ! IsNull( pSurfTm) )
stmSoup.AddSurfTriMesh( *Release( pSurfTm)) ;
else {
string sOut = "Non è riuscita la conversione di " + to_string( nSurf - i) + " superfici trimesh appartenenti ad una Brep" ;
LOG_ERROR( GetEExLogger(), sOut.c_str()) ;
return vSurf ;
}
}
else if ( nType == SRF_BEZIER ) {
PtrOwner<ISurfBezier> pSurfBezNew ( GetSurfBezier( Release( pSurf))) ;
// se ho più di un loop vuol dire che ho dei trim sulla faccia e quindi li aggiungo alla superficie di bezier
// prima della triangolazione
ON_BrepFace* onFace = onBrep->Face( i) ;
SurfFlatRegionByContours SfrCntr ;
if ( onFace->LoopCount() > 1) {
for ( int k = 0 ; k < onFace->LoopCount() ; ++k)
SfrCntr.AddCurve( ConvertBrepLoop( onFace->Loop( k))) ;
}
ISurfFlatRegion* sfrTrim = SfrCntr.GetSurf() ;
if ( ! IsNull( pSurfBezNew) ) {
// 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)
if ( onFace->LoopCount() > 1)
pSurfBezNew->SetTrimRegion( *sfrTrim) ;
if ( ! bForceTriMesh)
vSurf.push_back( Release( pSurfBezNew)) ;
else
stmSoup.AddSurfTriMesh( *(Release( pSurfBezNew)->GetAuxSurf())) ;
}
else {
string sOut = "Non è riuscita la conversione di " + to_string( nSurf - i) + " superfici NURBS appartenenti ad una Brep" ;
LOG_ERROR( GetEExLogger(), sOut.c_str()) ;
return vSurf ;
}
}
}
if ( ! stmSoup.End())
return vSurf ;
if ( bSurfTm || bForceTriMesh)
vSurf.push_back( GetSurfTriMesh( stmSoup.GetSurf())) ;
return vSurf ;
}
ICurve*
Import3dm::ConvertBrepLoop( const ON_BrepLoop* onBrepLoop)
{
int nTrim = onBrepLoop->TrimCount() ;
PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
for ( int i = 0 ; i < nTrim ; ++i) {
ON_BrepTrim* onBrepTrim = onBrepLoop->Trim( i) ;
ON_CurveProxy* onCurveProxy = ON_CurveProxy::Cast( onBrepTrim);
pCrvCompo->AddCurve( ConvertCurve( onCurveProxy)) ;
}
return Release( pCrvCompo) ;
}
Reference in New Issue View Git Blame Copy Permalink