Add build_items and components to work with real case data

Polyhedron/demo/Polyhedron/MainWindow.cpp

@@ -1206,8 +1206,7 @@ QList<Scene_item*> MainWindow::loadItem(QFileInfo fileinfo,
   }
   CGAL::Three::Three::CursorScopeGuard guard(QCursor(Qt::WaitCursor));
   QList<Scene_item*> result = loader->load(fileinfo, ok, add_to_scene);
-  selectSceneItem(scene->item_id(result.back()));
+  if(result.empty() || !ok)
-  if(!ok)
   {
     QApplication::restoreOverrideCursor();
       QMessageBox::warning(this, tr("Error"),
@@ -1215,6 +1214,7 @@ QList<Scene_item*> MainWindow::loadItem(QFileInfo fileinfo,
                                                       .arg(fileinfo.absoluteFilePath()).arg(loader->name()));
       return QList<Scene_item*>();
   }
+  selectSceneItem(scene->item_id(result.back()));
   for(Scene_item* item : result)
   {
     CGAL::Three::Scene_group_item* group =

Polyhedron/demo/Polyhedron/Plugins/IO/3mf_io_plugin.cpp

@@ -80,8 +80,13 @@ class Io_3mf_plugin:
     int nb_polylines =
         CGAL::read_polylines_from_3mf(fileinfo.filePath().toUtf8().toStdString(),
                                       all_points, all_colors, names);
-    if(nb_polylines > 0 )
+    if(nb_polylines < 0 )
     {
+      ok = false;
+      std::cerr << "Error in reading of meshes."<<std::endl;
+      return result;
+    }
+
     for(int i=0; i< nb_polylines; ++i)
     {
       Scene_polylines_item* pol_item = new Scene_polylines_item();
@@ -96,13 +101,18 @@ class Io_3mf_plugin:
       if(add_to_scene)
         CGAL::Three::Three::scene()->addItem(pol_item);
     }
-    }
     all_points.clear();
     all_colors.clear();
     names.clear();
     int nb_point_sets =
         CGAL::read_point_clouds_from_3mf(fileinfo.filePath().toUtf8().toStdString(),
                                          all_points, all_colors, names);
+    if(nb_point_sets < 0 )
+    {
+      ok = false;
+      std::cerr << "Error in reading of meshes."<<std::endl;
+      return result;
+    }
     for(int i=0; i< nb_point_sets; ++i)
     {
       Scene_points_with_normal_item* pts_item = new Scene_points_with_normal_item();
@@ -125,6 +135,12 @@ class Io_3mf_plugin:
     int nb_meshes =
         CGAL::read_soups_from_3mf(fileinfo.filePath().toUtf8().toStdString(),
                                   all_points, all_polygons, all_colors, names);
+    if(nb_meshes <0 )
+    {
+      ok = false;
+      std::cerr << "Error in reading of meshes."<<std::endl;
+      return result;
+    }
     for(std::size_t i = 0; i< nb_meshes; ++i)
     {
       PolygonRange triangles = all_polygons[i];
@@ -162,6 +178,8 @@ class Io_3mf_plugin:
           }
         }
         Scene_surface_mesh_item* sm_item = new Scene_surface_mesh_item(mesh);
+        if(first == CGAL::Color(0,0,0,0))
+          first = CGAL::Color(50,80,120,255);
         sm_item->setColor(QColor(first.red(), first.green(), first.blue()));
         sm_item->setProperty("already_colored", true);
         sm_item->setName(names[i].data());

Stream_support/include/CGAL/IO/read_3mf.h

@@ -26,13 +26,30 @@
 #include <algorithm>
 #include <functional>
 #include <CGAL/IO/Color.h>
+#include <CGAL/Kernel_traits.h>
 #include <Model/COM/NMR_DLLInterfaces.h>
 namespace CGAL{
 
+namespace transform_nmr_internal{
+NMR::MODELTRANSFORM initMatrix()
+{
+  NMR::MODELTRANSFORM mMatrix;
+  int i, j;
+  for (i = 0; i < 4; i++) {
+    for (j = 0; j < 3; j++) {
+      mMatrix.m_fFields[j][i] = (i == j) ? 1.0f : 0.0f;
+    }
+  }
+
+  return mMatrix;
+}
+}//end internal
+
 template<typename PointRange,
          typename PolygonRange,
          typename ColorRange>
 bool extract_soups (NMR::PLib3MFModelMeshObject *pMeshObject,
+                    const NMR::MODELTRANSFORM& transform,
                     PointRange& points,
                     PolygonRange& triangles,
                     ColorRange& colors,
@@ -40,10 +57,11 @@ bool extract_soups (NMR::PLib3MFModelMeshObject *pMeshObject,
   typedef typename PointRange::value_type Point_3;
   typedef typename PolygonRange::value_type Polygon;
   typedef typename ColorRange::value_type _Color;
-
+  typedef typename Kernel_traits<Point_3>::Kernel Kernel;
   HRESULT hResult;
   DWORD nNeededChars;
   std::vector<char> pBuffer;
+
   // Retrieve Mesh Name Length
   hResult = NMR::lib3mf_object_getnameutf8(pMeshObject, NULL, 0, &nNeededChars);
   if (hResult != LIB3MF_OK)
@@ -68,6 +86,12 @@ bool extract_soups (NMR::PLib3MFModelMeshObject *pMeshObject,
   else
     name = std::string("Unknown Mesh");
 
+  typename Kernel::Aff_transformation_3 t(
+        transform.m_fFields[0][0], transform.m_fFields[0][1], transform.m_fFields[0][2], transform.m_fFields[0][3],
+        transform.m_fFields[1][0], transform.m_fFields[1][1], transform.m_fFields[1][2], transform.m_fFields[1][3],
+        transform.m_fFields[2][0], transform.m_fFields[2][1], transform.m_fFields[2][2], transform.m_fFields[2][3]
+      );
+
   NMR::PLib3MFPropertyHandler * pPropertyHandler;
   hResult = NMR::lib3mf_meshobject_createpropertyhandler(pMeshObject, &pPropertyHandler);
   if (hResult != LIB3MF_OK) {
@@ -84,10 +108,10 @@ bool extract_soups (NMR::PLib3MFModelMeshObject *pMeshObject,
   {
     NMR::MODELMESHVERTEX pVertex;
     NMR::lib3mf_meshobject_getvertex(pMeshObject, vid, &pVertex);
-    points[vid] =
+    Point_3 p(pVertex.m_fPosition[0],
-        Point_3(pVertex.m_fPosition[0],
         pVertex.m_fPosition[1],
         pVertex.m_fPosition[2]);
+    points[vid] = t.transform(p);
   }
   for(DWORD pid = 0; pid < triangles.size(); ++pid)
   {
@@ -110,6 +134,7 @@ template<typename PointRange,
          typename PolygonRange,
          typename ColorRange>
 bool extract_polylines (NMR::PLib3MFModelMeshObject *pMeshObject,
+                        const NMR::MODELTRANSFORM& transform,
                         PointRange& points,
                         PolygonRange&,
                         ColorRange& colors,
@@ -183,6 +208,7 @@ template<typename PointRange,
          typename PolygonRange,
          typename ColorRange>
 bool extract_point_clouds (NMR::PLib3MFModelMeshObject *pMeshObject,
+                           const NMR::MODELTRANSFORM& transform,
                            PointRange& points,
                            PolygonRange&,
                            ColorRange& colors,
@@ -250,12 +276,14 @@ bool extract_point_clouds (NMR::PLib3MFModelMeshObject *pMeshObject,
   return true;
 }
 
+
 template<typename PointRanges, typename PolygonRanges, typename ColorRanges,
          typename PointRange, typename PolygonRange, typename ColorRange>
 int read_from_3mf(const std::string& file_name, PointRanges& all_points,
                   PolygonRanges& all_polygons, ColorRanges& all_colors,
                   std::vector<std::string>& names,
                   std::function<bool(NMR::PLib3MFModelMeshObject*,
+                                     const NMR::MODELTRANSFORM&,
                                      PointRange&,
                                      PolygonRange&,
                                      ColorRange&,
@@ -322,6 +350,11 @@ int read_from_3mf(const std::string& file_name, PointRanges& all_points,
     NMR::lib3mf_release(pModel);
     return -1;
   }
+
+  /**************************************************
+   **** Iterate Resources To Find Meshes ************
+   **************************************************/
+
   while (pbHasNext) {
     NMR::PLib3MFModelResource * pResource;
     NMR::PLib3MFModelMeshObject * pMeshObject;
@@ -349,8 +382,59 @@ int read_from_3mf(const std::string& file_name, PointRanges& all_points,
     // Query mesh interface
     BOOL bIsMeshObject;
     hResult = NMR::lib3mf_object_ismeshobject(pResource, &bIsMeshObject);
-    if ((hResult == LIB3MF_OK) && (bIsMeshObject)) {
+    if (hResult == LIB3MF_OK)
-      pMeshObject = pResource;
+    {
+      if(bIsMeshObject) {
+        //skip it. Only get it through the components and buildItems.
+      }
+      else {
+        BOOL bIsComponentsObject;
+        hResult = NMR::lib3mf_object_iscomponentsobject(pResource, &bIsComponentsObject);
+        if ((hResult == LIB3MF_OK) && (bIsComponentsObject)) {
+          pComponentsObject = (NMR::PLib3MFModelComponentsObject*)pResource;
+          DWORD nComponentCount;
+          hResult = NMR::lib3mf_componentsobject_getcomponentcount(pComponentsObject, &nComponentCount);
+          if (hResult != LIB3MF_OK)
+            return -1;
+          //for each component
+          DWORD nIndex;
+          for (nIndex = 0; nIndex < nComponentCount; ++nIndex) {
+            NMR::PLib3MFModelResource * compResource;
+            NMR::PLib3MFModelComponent * pComponent;
+            hResult = NMR::lib3mf_componentsobject_getcomponent(pComponentsObject, nIndex, &pComponent);
+            if (hResult != LIB3MF_OK) {
+              return -1;
+            }
+
+            hResult = NMR::lib3mf_component_getobjectresource(pComponent, &compResource);
+            if (hResult != LIB3MF_OK) {
+              NMR::lib3mf_release(pComponent);
+              return -1;
+            }
+            hResult = NMR::lib3mf_object_ismeshobject(compResource, &bIsMeshObject);
+            if (hResult == LIB3MF_OK)
+            {
+              if(bIsMeshObject) {
+                BOOL bHasTransform;
+                NMR::MODELTRANSFORM Transform;
+                hResult = NMR::lib3mf_component_hastransform(pComponent, &bHasTransform);
+                if (hResult != LIB3MF_OK) {
+                  NMR::lib3mf_release(pComponent);
+                  return -1;
+                }
+
+                if (bHasTransform) {
+                  // Retrieve Transform
+                  hResult = NMR::lib3mf_component_gettransform(pComponent, &Transform);
+                  if (hResult != LIB3MF_OK) {
+                    NMR::lib3mf_release(pComponent);
+                    return -1;
+                  }
+                }
+                else {
+                  Transform = transform_nmr_internal::initMatrix();
+                }
+                pMeshObject = compResource;
                 NMR::lib3mf_meshobject_getvertexcount(pMeshObject, &nbVertices);
                 NMR::lib3mf_meshobject_gettrianglecount(pMeshObject, &nbPolygons);
                 PointRange points (nbVertices);
@@ -358,13 +442,19 @@ int read_from_3mf(const std::string& file_name, PointRanges& all_points,
                 ColorRange colors(nbPolygons);
                 std::string name;
 
-      if(func(pMeshObject, points, triangles, colors, name)){
+                if(func(pMeshObject, Transform, points, triangles, colors, name)){
                   all_points.push_back(points);
                   all_polygons.push_back(triangles);
                   all_colors.push_back(colors);
                   names.push_back(name);
                 }
               }
+            }
+          }
+          //end component
+        }
+      }
+    }
     // free instances
     NMR::lib3mf_release(pResource);
     hResult = NMR::lib3mf_resourceiterator_movenext(pResourceIterator, &pbHasNext);
@@ -373,6 +463,116 @@ int read_from_3mf(const std::string& file_name, PointRanges& all_points,
       return -1;
     }
   }
+
+
+  /********************************************************
+   **** Iterate Build items To Find Transformed Meshes ****
+   ********************************************************/
+
+  // Iterate through all the Build items
+  NMR::PLib3MFModelBuildItemIterator * pBuildItemIterator;
+  hResult = NMR::lib3mf_model_getbuilditems(pModel, &pBuildItemIterator);
+  if (hResult != LIB3MF_OK) {
+    std::cout << "could not get build items: " << std::hex << hResult << std::endl;
+    NMR::lib3mf_release(pBuildItemIterator);
+    NMR::lib3mf_release(pModel);
+    return -1;
+  }
+
+  hResult = NMR::lib3mf_builditemiterator_movenext(pBuildItemIterator, &pbHasNext);
+  if (hResult != LIB3MF_OK) {
+    std::cout << "could not get next build item: " << std::hex << hResult << std::endl;
+    NMR::lib3mf_release(pBuildItemIterator);
+    NMR::lib3mf_release(pModel);
+    return -1;
+  }
+
+  while (pbHasNext) {
+    NMR::PLib3MFModelMeshObject * pMeshObject;
+    NMR::MODELTRANSFORM Transform;
+    NMR::PLib3MFModelBuildItem * pBuildItem;
+    // Retrieve Build Item
+    hResult = NMR::lib3mf_builditemiterator_getcurrent(pBuildItemIterator, &pBuildItem);
+    if (hResult != LIB3MF_OK) {
+      std::cout << "could not get build item: " << std::hex << hResult << std::endl;
+      NMR::lib3mf_release(pBuildItemIterator);
+      NMR::lib3mf_release(pModel);
+      return -1;
+    }
+
+    // Retrieve Resource
+    NMR::PLib3MFModelObjectResource * pObjectResource;
+    hResult = NMR::lib3mf_builditem_getobjectresource(pBuildItem, &pObjectResource);
+    if (hResult != LIB3MF_OK) {
+      std::cout << "could not get build item resource: " << std::hex << hResult << std::endl;
+      NMR::lib3mf_release(pBuildItem);
+      NMR::lib3mf_release(pBuildItemIterator);
+      NMR::lib3mf_release(pModel);
+      return -1;
+    }
+
+    BOOL bIsMeshObject;
+    hResult = NMR::lib3mf_object_ismeshobject(pObjectResource, &bIsMeshObject);
+    if (hResult == LIB3MF_OK)
+    {
+      if(bIsMeshObject) {
+        pMeshObject = pObjectResource;
+        NMR::lib3mf_meshobject_getvertexcount(pMeshObject, &nbVertices);
+        NMR::lib3mf_meshobject_gettrianglecount(pMeshObject, &nbPolygons);
+        PointRange points (nbVertices);
+        PolygonRange triangles(nbPolygons);
+        ColorRange colors(nbPolygons);
+        std::string name;
+
+
+        // Check Object Transform
+        BOOL bHasTransform;
+        hResult = NMR::lib3mf_builditem_hasobjecttransform(pBuildItem, &bHasTransform);
+        if (hResult != LIB3MF_OK) {
+          NMR::lib3mf_release(pBuildItem);
+          NMR::lib3mf_release(pBuildItemIterator);
+          NMR::lib3mf_release(pModel);
+          std::cerr << "could not check object transform: " << std::hex << hResult << std::endl;
+          return -1;
+        }
+
+        if (bHasTransform) {
+          // Retrieve Transform
+          hResult = NMR::lib3mf_builditem_getobjecttransform(pBuildItem, &Transform);
+          if (hResult != LIB3MF_OK) {
+            NMR::lib3mf_release(pBuildItem);
+            NMR::lib3mf_release(pBuildItemIterator);
+            NMR::lib3mf_release(pModel);
+            std::cerr << "could not get object transform: " << std::hex << hResult << std::endl;
+            return -1;
+          }
+        }
+        else {
+          Transform = transform_nmr_internal::initMatrix();
+        }
+
+        if(func(pMeshObject, Transform, points, triangles, colors, name)){
+          all_points.push_back(points);
+          all_polygons.push_back(triangles);
+          all_colors.push_back(colors);
+          names.push_back(name);
+        }
+      }
+    }
+    // Release Object Resource ID
+    NMR::lib3mf_release(pObjectResource);
+    // Release Build Item
+    NMR::lib3mf_release(pBuildItem);
+
+    // Move to next Item
+    hResult = NMR::lib3mf_builditemiterator_movenext(pBuildItemIterator, &pbHasNext);
+    if (hResult != LIB3MF_OK) {
+      std::cerr << "could not get next build item: " << std::hex << hResult << std::endl;
+      return -1;
+    }
+  }
+  // Release Build Item Iterator
+  NMR::lib3mf_release(pBuildItemIterator);
   return all_points.size();
 }
 

Stream_support/include/CGAL/IO/write_3mf.h

@@ -218,6 +218,9 @@ bool write_mesh_to_model( const PointRange& points,
     NMR::lib3mf_release(pModel);
     return -1;
   }
+
+  //add a builditem to finish
+  add_build_item(pModel, *pMeshObject);
 }
 
 //remember that it adds 3 demmy vertices in the beginning, and a dummy triangle to be ignored.
@@ -314,6 +317,7 @@ bool write_points(const PointRange& points,
     NMR::lib3mf_release(pModel);
     return -1;
   }
+  add_build_item(pModel, *pMeshObject);
 }
 
 template<typename PointRange, typename Color>
@@ -390,6 +394,7 @@ bool write_soups_to_3mf(const std::string& file_name,
     else
       name = std::string("");
     write_mesh_to_model(all_points[id], all_polygons[id], name, &pMeshObject, pModel);
+    add_build_item(pModel, pMeshObject);
     //write_mesh_object_to_model(pModel, pMeshObject);
   }
   return export_model_to_file(file_name, pModel);