Use PolySet::createEmpty()

openscad · Mar 5, 2024 · c1c146e · c1c146e
1 parent bc8491f
commit c1c146e
Show file tree

Hide file tree

Showing 12 changed files with 77 additions and 77 deletions.
diff --git a/src/core/ImportNode.cc b/src/core/ImportNode.cc
@@ -211,7 +211,7 @@ std::unique_ptr<const Geometry> ImportNode::createGeometry() const
 #endif
   default:
     LOG(message_group::Error, "Unsupported file format while trying to import file '%1$s', import() at line %2$d", this->filename, loc.firstLine());
-    g = std::make_unique<PolySet>(3);
+    g = PolySet::createEmpty();
   }
 
   g->setConvexity(this->convexity);

diff --git a/src/core/primitives.cc b/src/core/primitives.cc
@@ -111,7 +111,7 @@ std::unique_ptr<const Geometry> CubeNode::createGeometry() const
     || this->y <= 0 || !std::isfinite(this->y)
     || this->z <= 0 || !std::isfinite(this->z)
     ) {
-    return std::make_unique<PolySet>(3, true);
+    return PolySet::createEmpty();
   }
 
   double x1, x2, y1, y2, z1, z2;
@@ -184,7 +184,7 @@ static std::shared_ptr<AbstractNode> builtin_cube(const ModuleInstantiation *ins
 std::unique_ptr<const Geometry> SphereNode::createGeometry() const
 {
   if (this->r <= 0 || !std::isfinite(this->r)) {
-    return std::make_unique<PolySet>(3, true);
+    return PolySet::createEmpty();
   }
 
   auto num_fragments = Calc::get_fragments_from_r(r, fn, fs, fa);
@@ -263,7 +263,7 @@ std::unique_ptr<const Geometry> CylinderNode::createGeometry() const
     || this->r2 < 0 || !std::isfinite(this->r2)
     || (this->r1 <= 0 && this->r2 <= 0)
     ) {
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   auto num_fragments = Calc::get_fragments_from_r(std::fmax(this->r1, this->r2), this->fn, this->fs, this->fa);
@@ -404,7 +404,7 @@ std::string PolyhedronNode::toString() const
 
 std::unique_ptr<const Geometry> PolyhedronNode::createGeometry() const
 {
-  auto p = std::make_unique<PolySet>(3);
+  auto p = PolySet::createEmpty();
   p->setConvexity(this->convexity);
   p->vertices=this->points;
   p->indices=this->faces;

diff --git a/src/geometry/GeometryEvaluator.cc b/src/geometry/GeometryEvaluator.cc
@@ -256,7 +256,7 @@ std::unique_ptr<Geometry> GeometryEvaluator::applyHull3D(const AbstractNode& nod
 {
   Geometry::Geometries children = collectChildren3D(node);
 
-  auto P = std::make_unique<PolySet>(3);
+  auto P = PolySet::createEmpty();
   return applyHull(children);
 }
 
@@ -1041,7 +1041,7 @@ static std::unique_ptr<Geometry> extrudePolygon(const LinearExtrudeNode& node, c
   if (isConvex && non_linear) isConvex = unknown;
   PolySetBuilder builder(0, 0, 3, isConvex);
   builder.setConvexity(node.convexity);
-  if (node.height <= 0) return std::make_unique<PolySet>(3);
+  if (node.height <= 0) return PolySet::createEmpty();
 
   size_t slices;
   if (node.has_slices) {
@@ -1567,7 +1567,7 @@ Response GeometryEvaluator::visit(State& state, const RoofNode& node)
         } catch (RoofNode::roof_exception& e) {
           LOG(message_group::Error, node.modinst->location(), this->tree.getDocumentPath(),
               "Skeleton computation error. " + e.message());
-          roof = std::make_unique<PolySet>(3);
+          roof = PolySet::createEmpty();
         }
         assert(roof);
         geom = std::move(roof);

diff --git a/src/geometry/PolySet.h b/src/geometry/PolySet.h
@@ -36,8 +36,8 @@ class PolySet : public Geometry
   boost::tribool convexValue() const { return this->convex; }
   bool isTriangular = false;
 
-  static std::unique_ptr<PolySet> createEmpty() { return PolySet::createEmpty(); }
-}
+  static std::unique_ptr<PolySet> createEmpty() { return std::make_unique<PolySet>(3); }
+
 private:
   unsigned int dim;
   mutable boost::tribool convex;

diff --git a/src/geometry/PolySetUtils.cc b/src/geometry/PolySetUtils.cc
@@ -164,7 +164,7 @@ std::shared_ptr<const PolySet> getGeometryAsPolySet(const std::shared_ptr<const
       }
       LOG(message_group::Error, "Nef->PolySet failed.");
     }
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
   if (auto hybrid = std::dynamic_pointer_cast<const CGALHybridPolyhedron>(geom)) {
     return hybrid->toPolySet();

diff --git a/src/geometry/cgal/cgalutils.cc b/src/geometry/cgal/cgalutils.cc
@@ -375,7 +375,7 @@ std::unique_ptr<PolySet> createPolySetFromNefPolyhedron3(const CGAL::Nef_polyhed
     LOG(message_group::Error, "Non-manifold mesh created: %1$d unconnected edges", unconnected2);
   }
 
-  auto polyset = std::make_unique<PolySet>(3);
+  auto polyset = PolySet::createEmpty();
   polyset->vertices.reserve(verts.size());
   for (const auto& v : verts) {
     polyset->vertices.emplace_back(v.cast<double>());

diff --git a/src/io/export.cc b/src/io/export.cc
@@ -195,7 +195,7 @@ struct LexographicLess {
 
 std::unique_ptr<PolySet> createSortedPolySet(const PolySet& ps)
 {
-  auto out = std::make_unique<PolySet>(3);
+  auto out = PolySet::createEmpty();
 
   std::map<Vector3d, int, LexographicLess> vertexMap;
 

diff --git a/src/io/import_3mf.cc b/src/io/import_3mf.cc
@@ -65,7 +65,7 @@ static std::unique_ptr<PolySet> import_3mf_error(PLib3MFModel *model = nullptr,
     lib3mf_release(object_it);
   }
 
-  return std::make_unique<PolySet>(3);
+  return PolySet::createEmpty();
 }
 
 std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location& loc)
@@ -74,14 +74,14 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
   HRESULT result = lib3mf_getinterfaceversion(&interfaceVersionMajor, &interfaceVersionMinor, &interfaceVersionMicro);
   if (result != LIB3MF_OK) {
     LOG(message_group::Error, "Error reading 3MF library version");
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   if ((interfaceVersionMajor != NMR_APIVERSION_INTERFACE_MAJOR)) {
     LOG(message_group::Error, "Invalid 3MF library major version %1$d.%2$d.%3$d, expected %4$d.%5$d.%6$d",
         interfaceVersionMajor, interfaceVersionMinor, interfaceVersionMicro,
         NMR_APIVERSION_INTERFACE_MAJOR, NMR_APIVERSION_INTERFACE_MINOR, NMR_APIVERSION_INTERFACE_MICRO);
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   PLib3MFModel *model;
@@ -173,7 +173,7 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
   lib3mf_release(model);
 
   if (!first_mesh) {
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   } else if (meshes.empty()) {
     return first_mesh;
   } else {
@@ -187,10 +187,10 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
     if (auto ps = PolySetUtils::getGeometryAsPolySet(CGALUtils::applyUnion3D(children.begin(), children.end()))) {
       p = std::make_unique<PolySet>(*ps);
     } else {
-      p = std::make_unique<PolySet>(3);
+      p = PolySet::createEmpty();
     }
 #else
-    p = std::make_unique<PolySet>(3);
+    p = PolySet::createEmpty();
 #endif // ifdef ENABLE_CGAL
     return p;
   }
@@ -237,48 +237,48 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
       LOG(message_group::Error, "Invalid 3MF library major version %1$d.%2$d.%3$d, expected %4$d.%5$d.%6$d",
           interfaceVersionMajor, interfaceVersionMinor, interfaceVersionMicro,
           LIB3MF_VERSION_MAJOR, LIB3MF_VERSION_MINOR, LIB3MF_VERSION_MICRO);
-      return std::make_unique<PolySet>(3);
+      return PolySet::createEmpty();
     }
   } catch (const Lib3MF::ELib3MFException& e) {
     LOG(message_group::Export_Error, e.what());
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   Lib3MF::PModel model;
   try {
     model = wrapper->CreateModel();
     if (!model) {
       LOG(message_group::Error, "Could not create model");
-      return std::make_unique<PolySet>(3);
+      return PolySet::createEmpty();
     }
   } catch (const Lib3MF::ELib3MFException& e) {
     LOG(message_group::Export_Error, e.what());
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   Lib3MF::PReader reader;
   try {
     reader = model->QueryReader("3mf");
     if (!reader) {
       LOG(message_group::Error, "Could not create 3MF reader");
-      return std::make_unique<PolySet>(3);
+      return PolySet::createEmpty();
     }
   } catch (const Lib3MF::ELib3MFException& e) {
     LOG(message_group::Export_Error, "Could create 3MF reader, import() at line %1$d: %2$s", loc.firstLine(), e.what());
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   try {
     reader->ReadFromFile(filename);
   } catch (const Lib3MF::ELib3MFException& e) {
     LOG(message_group::Warning, "Could not read file '%1$s', import() at line %2$d: %3$s", filename.c_str(), loc.firstLine(), e.what());
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   Lib3MF::PMeshObjectIterator object_it;
   object_it = model->GetMeshObjects();
   if (!object_it) {
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
 
   std::unique_ptr<PolySet> first_mesh;
@@ -290,20 +290,20 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
     try {
       object = object_it->GetCurrentMeshObject();
       if (!object) {
-        return std::make_unique<PolySet>(3);
+        return PolySet::createEmpty();
       }
     } catch (const Lib3MF::ELib3MFException& e) {
       LOG(message_group::Error, e.what());
-      return std::make_unique<PolySet>(3);
+      return PolySet::createEmpty();
     }
 
     Lib3MF_uint64 vertex_count = object->GetVertexCount();
     if (!vertex_count) {
-      return std::make_unique<PolySet>(3);
+      return PolySet::createEmpty();
     }
     Lib3MF_uint64 triangle_count = object->GetTriangleCount();
     if (!triangle_count) {
-      return std::make_unique<PolySet>(3);
+      return PolySet::createEmpty();
     }
 
     PRINTDB("%s: mesh %d, vertex count: %lu, triangle count: %lu", filename.c_str() % mesh_idx % vertex_count % triangle_count);
@@ -330,7 +330,7 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
   }
 
   if (first_mesh == 0) {
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   } else if (meshes.empty()) {
     return first_mesh;
   } else {
@@ -347,10 +347,10 @@ std::unique_ptr<Geometry> import_3mf(const std::string& filename, const Location
       // FIXME: unnecessary copy
       p = std::make_unique<PolySet>(*ps);
     } else {
-      p = std::make_unique<PolySet>(3);
+      p = PolySet::createEmpty();
     }
 #else
-    p = std::make_unique<PolySet>(3);
+    p = PolySet::createEmpty();
 #endif // ifdef ENABLE_CGAL
     return p;
   }
@@ -368,7 +368,7 @@ const std::string get_lib3mf_version() {
 std::unique_ptr<Geometry> import_3mf(const std::string&, const Location& loc)
 {
   LOG(message_group::Warning, "Import from 3MF format was not enabled when building the application, import() at line %1$d", loc.firstLine());
-  return std::make_unique<PolySet>(3);
+  return PolySet::createEmpty();
 }
 
 #endif // ENABLE_LIB3MF
diff --git a/src/io/import_amf.cc b/src/io/import_amf.cc
@@ -254,7 +254,7 @@ std::unique_ptr<PolySet> AmfImporter::read(const std::string& filename)
   vertex_list.clear();
 
   if (polySets.empty()) {
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
   if (polySets.size() == 1) {
     return std::move(polySets[0]);
@@ -274,7 +274,7 @@ std::unique_ptr<PolySet> AmfImporter::read(const std::string& filename)
 #endif // ENABLE_CGAL
       LOG(message_group::Error, "Error importing multi-object AMF file '%1$s', import() at line %2$d", filename, this->loc.firstLine());
   }
-  return std::make_unique<PolySet>(3);
+  return PolySet::createEmpty();
 }
 
 #ifdef ENABLE_LIBZIP

diff --git a/src/io/import_obj.cc b/src/io/import_obj.cc
@@ -16,7 +16,7 @@ std::unique_ptr<PolySet> import_obj(const std::string& filename, const Location&
     LOG(message_group::Warning,
         "Can't open import file '%1$s', import() at line %2$d",
         filename, loc.firstLine());
-    return std::make_unique<PolySet>(3);
+    return PolySet::createEmpty();
   }
   boost::regex ex_comment(R"(^\s*#)");
   boost::regex ex_v( R"(^\s*v\s+([^\s]+)\s+([^\s]+)\s+([^\s]+)\s*$)");
@@ -36,7 +36,7 @@ std::unique_ptr<PolySet> import_obj(const std::string& filename, const Location&
     "OBJ File line %1$s, %2$s line '%3$s' importing file '%4$s'",
     lineno, errstr, line, filename);
   };
-  std::vector<int> vertex_map;	
+  std::vector<int> vertex_map;        
 
   while (!f.eof()) {
     lineno++;
@@ -48,14 +48,14 @@ std::unique_ptr<PolySet> import_obj(const std::string& filename, const Location&
       continue;
     } else if (boost::regex_search(line, results, ex_v) && results.size() >= 4) {
       try {
-	Vector3d v;
+        Vector3d v;
         for (int i = 0; i < 3; i++) {
           v[i]= boost::lexical_cast<double>(results[i + 1]); 
         }
         vertex_map.push_back(builder.vertexIndex(v));
       } catch (const boost::bad_lexical_cast& blc) {
         AsciiError("can't parse vertex");
-        return std::make_unique<PolySet>(3);
+        return PolySet::createEmpty();
       }
     } else if (boost::regex_search(line, results, ex_f) && results.size() >= 2) {
       std::string args=results[1];
@@ -65,16 +65,16 @@ std::unique_ptr<PolySet> import_obj(const std::string& filename, const Location&
       for (const std::string& word : words) {
         std::vector<std::string> wordindex;
         boost::split(wordindex, word, boost::is_any_of("/"));
-	if(wordindex.size() < 1)
+        if(wordindex.size() < 1)
           LOG(message_group::Warning, "Invalid Face index in File %1$s in Line %2$d", filename, lineno);
-	else {
-	  int ind=boost::lexical_cast<int>(wordindex[0]);
+        else {
+          int ind=boost::lexical_cast<int>(wordindex[0]);
           if(ind >= 1 && ind  <= vertex_map.size()) {
             builder.appendVertex(vertex_map[ind-1]);
-	  } else {  
+          } else {  
             LOG(message_group::Warning, "Index %1$d out of range in Line %2$d", filename, lineno);
-	  }
-	} 
+          }
+        } 
       }
 
     } else if (boost::regex_search(line, results, ex_vt)) { // ignore texture coords