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,22 +80,26 @@ 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 )
     {
-      for(int i=0; i< nb_polylines; ++i)
+      ok = false;
-      {
+      std::cerr << "Error in reading of meshes."<<std::endl;
-        Scene_polylines_item* pol_item = new Scene_polylines_item();
+      return result;
-        PolylineRange& polylines = pol_item->polylines;
+    }
-        polylines.push_back(all_points[i]);
+
-        pol_item->setName(names[i].data());
+    for(int i=0; i< nb_polylines; ++i)
-        pol_item->invalidateOpenGLBuffers();
+    {
-        CGAL::Color c = all_colors[i].front();
+      Scene_polylines_item* pol_item = new Scene_polylines_item();
-        pol_item->setColor(QColor(c.red(), c.green(), c.blue()));
+      PolylineRange& polylines = pol_item->polylines;
-        pol_item->setProperty("already_colord", true);
+      polylines.push_back(all_points[i]);
-        result << pol_item;
+      pol_item->setName(names[i].data());
-        if(add_to_scene)
+      pol_item->invalidateOpenGLBuffers();
-          CGAL::Three::Three::scene()->addItem(pol_item);
+      CGAL::Color c = all_colors[i].front();
-      }
+      pol_item->setColor(QColor(c.red(), c.green(), c.blue()));
+      pol_item->setProperty("already_colord", true);
+      result << pol_item;
+      if(add_to_scene)
+        CGAL::Three::Three::scene()->addItem(pol_item);
     }
     all_points.clear();
     all_colors.clear();
@@ -103,6 +107,12 @@ class Io_3mf_plugin:
     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,24 +26,42 @@
 #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,
-           PointRange& points,
+                    const NMR::MODELTRANSFORM& transform,
-           PolygonRange& triangles,
+                    PointRange& points,
-           ColorRange& colors,
+                    PolygonRange& triangles,
-           std::string& name) {
+                    ColorRange& colors,
+                    std::string& name) {
   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,10 +134,11 @@ template<typename PointRange,
          typename PolygonRange,
          typename ColorRange>
 bool extract_polylines (NMR::PLib3MFModelMeshObject *pMeshObject,
-           PointRange& points,
+                        const NMR::MODELTRANSFORM& transform,
-           PolygonRange&,
+                        PointRange& points,
-           ColorRange& colors,
+                        PolygonRange&,
-           std::string& name) {
+                        ColorRange& colors,
+                        std::string& name) {
   typedef typename PointRange::value_type Point_3;
   typedef typename PolygonRange::value_type Polygon;
 
@@ -175,7 +200,7 @@ bool extract_polylines (NMR::PLib3MFModelMeshObject *pMeshObject,
   NMR::lib3mf_propertyhandler_getcolor(pPropertyHandler, 0, &pColor);//get color of the dummy triangle
   NMR::MODELMESHCOLOR_SRGB mColor = pColor.m_Colors[0];
   colors[0]=CGAL::Color(mColor.m_Red, mColor.m_Green,
-                          mColor.m_Blue, mColor.m_Alpha);
+                        mColor.m_Blue, mColor.m_Alpha);
   return true;
 }
 
@@ -183,10 +208,11 @@ template<typename PointRange,
          typename PolygonRange,
          typename ColorRange>
 bool extract_point_clouds (NMR::PLib3MFModelMeshObject *pMeshObject,
-           PointRange& points,
+                           const NMR::MODELTRANSFORM& transform,
-           PolygonRange&,
+                           PointRange& points,
-           ColorRange& colors,
+                           PolygonRange&,
-           std::string& name) {
+                           ColorRange& colors,
+                           std::string& name) {
   typedef typename PointRange::value_type Point_3;
 
   HRESULT hResult;
@@ -246,16 +272,18 @@ bool extract_point_clouds (NMR::PLib3MFModelMeshObject *pMeshObject,
   NMR::lib3mf_propertyhandler_getcolor(pPropertyHandler, 0, &pColor);//get color of the dummy triangle
   NMR::MODELMESHCOLOR_SRGB mColor = pColor.m_Colors[0];
   colors[0]=CGAL::Color(mColor.m_Red, mColor.m_Green,
-                          mColor.m_Blue, mColor.m_Alpha);
+                        mColor.m_Blue, mColor.m_Alpha);
   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,
+                  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,20 +382,77 @@ 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;
+    {
-      NMR::lib3mf_meshobject_getvertexcount(pMeshObject, &nbVertices);
+      if(bIsMeshObject) {
-      NMR::lib3mf_meshobject_gettrianglecount(pMeshObject, &nbPolygons);
+        //skip it. Only get it through the components and buildItems.
-      PointRange points (nbVertices);
+      }
-      PolygonRange triangles(nbPolygons);
+      else {
-      ColorRange colors(nbPolygons);
+        BOOL bIsComponentsObject;
-      std::string name;
+        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;
+            }
 
-      if(func(pMeshObject, points, triangles, colors, name)){
+            hResult = NMR::lib3mf_component_getobjectresource(pComponent, &compResource);
-        all_points.push_back(points);
+            if (hResult != LIB3MF_OK) {
-        all_polygons.push_back(triangles);
+              NMR::lib3mf_release(pComponent);
-        all_colors.push_back(colors);
+              return -1;
-        names.push_back(name);
+            }
+            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);
+                PolygonRange triangles(nbPolygons);
+                ColorRange colors(nbPolygons);
+                std::string 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
@@ -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();
 }
 
@@ -408,7 +608,7 @@ template<typename PointRanges, typename PolygonRanges, typename ColorRanges>
 int read_soups_from_3mf(const std::string& file_name, PointRanges& all_points,
                         PolygonRanges& all_polygons, ColorRanges& all_colors,
                         std::vector<std::string>& names
-                  )
+                        )
 {
   typedef typename PointRanges::value_type PointRange;
   typedef typename PolygonRanges::value_type PolygonRange;
@@ -425,7 +625,7 @@ int read_polylines_from_3mf(const std::string& file_name,
                             PointRanges& all_points,
                             ColorRanges& all_colors,
                             std::vector<std::string>& names
-                  )
+                            )
 {
   typedef typename PointRanges::value_type PointRange;
   typedef std::vector<std::size_t> Polygon;
@@ -444,7 +644,7 @@ int read_point_clouds_from_3mf(const std::string& file_name,
                                PointRanges& all_points,
                                ColorRanges& all_colors,
                                std::vector<std::string>& names
-                  )
+                               )
 {
   typedef typename PointRanges::value_type PointRange;
   typedef std::vector<std::size_t> Polygon;

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);