resolve benchmark bug

Author: chitalu

include/mcut/internal/nfg/memPool.h

@@ -250,23 +250,47 @@ inline IN_pool::IN_pool(IN_pool&& p) noexcept
 //    If V==0 use standard free()
 //    else if V==N release a block is the corresponding IN_pool
 
+#if 1
+#include <type_traits>
+template <typename T>
+ int CountLeadingZeros(const T& DATA)
+{
+	T MASK{1};
+	int BITSN{sizeof(T) * CHAR_BIT}, LEADINGN{0};
+	MASK <<= BITSN - 1;
+	for(int I = BITSN; I > 0; I--, LEADINGN++, MASK >>= 1)
+	{
+		if(DATA & MASK)
+		{
+			break;
+		}
+	}
+	return LEADINGN;
+}
+#endif
 class MultiPool
 {
 	std::vector<IN_pool> IN_pools;
 	uint32_t max_block_size;
 
 	IN_pool& pickPoolFromSize(uint32_t bs)
 	{
-		#if 0
+#if 0
 		auto cz = std::countl_zero(bs - 1);
 		cz = (cz == 32) ? (31) : (cz);
 		return IN_pools[31 - cz];
-		#else
+#else
+#if 0
+		auto cz = CountLeadingZeros(bs - 1);
+		cz = (cz == 32) ? (31) : (cz);
+		return IN_pools[31 - cz];
+#else
 		//// FOR COMPILERS THAT DO NOT SUPPORT C++20 REPLACE THE ABOVE WITH THE FOLLOWING
 		std::vector<IN_pool>::iterator i = IN_pools.begin();
 		while ((*i).blockSize() < bs) i++;
 		return *i;
-		#endif
+#endif
+#endif
 	}
 
 public:

source/bvh.cpp

@@ -301,23 +301,44 @@ void build_oibvh(
 
 #if defined(MCUT_WITH_COMPUTE_HELPER_THREADPOOL)
     {
+#if 1
         std::mutex bbox_expansion_mtx;
-        auto fn_compute_mesh_bbox = [&](vertex_array_iterator_t block_start_, vertex_array_iterator_t block_end_) {
+		auto fn_compute_mesh_bbox = [&](std::vector<bounding_box_t<vec3>>::const_iterator block_start_,
+				std::vector<bounding_box_t<vec3>>::const_iterator block_end_) {
             bounding_box_t<vec3> meshBbox_local;
-            for (vertex_array_iterator_t v = block_start_; v != block_end_; ++v) {
-                const vec3& coords = mesh.vertex(*v);
-                meshBbox_local.expand(coords);
+				for(std::vector<bounding_box_t<vec3>>::const_iterator v = block_start_;
+					v != block_end_;
+					++v)
+			{
+                //const vec3& coords = mesh.vertex(*v);
+				meshBbox_local.expand(*v /*coords*/);
             }
 
             std::lock_guard<std::mutex> lock(bbox_expansion_mtx);
             meshBbox.expand(meshBbox_local);
         };
 
         parallel_for(
-            pool,
-            mesh.vertices_begin(),
-            mesh.vertices_end(),
+            pool, face_bboxes.cbegin()/*mesh.vertices_begin()*/,
+					 face_bboxes.cend()/*mesh.vertices_end()*/,
             fn_compute_mesh_bbox);
+#else
+		std::mutex bbox_expansion_mtx;
+		auto fn_compute_mesh_bbox = [&](vertex_array_iterator_t block_start_,
+										vertex_array_iterator_t block_end_) {
+			bounding_box_t<vec3> meshBbox_local;
+			for(vertex_array_iterator_t v = block_start_; v != block_end_; ++v)
+			{
+				const vec3& coords = mesh.vertex(*v);
+				meshBbox_local.expand(coords);
+			}
+
+			std::lock_guard<std::mutex> lock(bbox_expansion_mtx);
+			meshBbox.expand(meshBbox_local);
+		};
+
+		parallel_for(pool, mesh.vertices_begin(), mesh.vertices_end(), fn_compute_mesh_bbox);
+#endif
     }
 #else
     // for each vertex in mesh

source/kernel.cpp

@@ -4145,7 +4145,7 @@ void dispatch(output_t& output, const input_t& input)
                 if (prev_edge == hmesh_t::null_edge() || fpi.polygon_vertices.size() < cutpath_sequence.size()) {
                     const std::vector<ed_t>& evec = SAFE_ACCESS(ivtx_to_cp_edges, cur->first);
                     std::vector<ed_t>::const_iterator fiter = std::find_if(evec.cbegin(), evec.cend(), [&](const ed_t& e) { return e != prev_edge; });
-
+					MCUT_ASSERT(fiter != evec.cend());
                     ed_t edge = *fiter;
                     vd_t next_vertex = m0.vertex(edge, 0);
 

source/math.cpp

@@ -970,8 +970,8 @@
         num = a[0] * (d[1] - c[1]) + //
             c[0] * (a[1] - d[1]) + //
             d[0] * (c[1] - a[1]);
-		std::cout << "test\n";
-        std::cout << num.get_str() << std::endl << denom.get_str() << std::endl;
+		//std::cout << "test\n";
+        //std::cout << num.get_str() << std::endl << denom.get_str() << std::endl;
         if ((num == scalar_t(0.0)) || (num == denom)) {
             code = 'v';
         }

source/preproc.cpp

@@ -93,9 +93,9 @@ bool client_input_arrays_to_hmesh(std::shared_ptr<context_t>& context_ptr,
 		{
 
 #if MCUT_WITH_ARBITRARY_PRECISION_NUMBERS
-			const float& x = (vptr[(i * 3) + 0] - srcmesh_cutmesh_com[0]) + pre_quantization_translation[0];
-			const float& y = (vptr[(i * 3) + 1] - srcmesh_cutmesh_com[1]) + pre_quantization_translation[1];
-			const float& z = (vptr[(i * 3) + 2] - srcmesh_cutmesh_com[2]) + pre_quantization_translation[2];
+			const float x = (vptr[(i * 3) + 0] - srcmesh_cutmesh_com[0]) + pre_quantization_translation[0];
+			const float y = (vptr[(i * 3) + 1] - srcmesh_cutmesh_com[1]) + pre_quantization_translation[1];
+			const float z = (vptr[(i * 3) + 2] - srcmesh_cutmesh_com[2]) + pre_quantization_translation[2];
 			vec3 quantized_vertex(scalar_t::quantize(x, multiplier),
 								  scalar_t::quantize(y, multiplier),
 								  scalar_t::quantize(z, multiplier));
@@ -117,11 +117,11 @@ bool client_input_arrays_to_hmesh(std::shared_ptr<context_t>& context_ptr,
 
 			vd_t vd = halfedgeMesh.add_vertex(quantized_vertex);
 #else
-			const float& x =
+			const float x =
 				(vptr[(i * 3) + 0] - srcmesh_cutmesh_com[0]) + pre_quantization_translation[0];
-			const float& y =
+			const float y =
 				(vptr[(i * 3) + 1] - srcmesh_cutmesh_com[1]) + pre_quantization_translation[1];
-			const float& z =
+			const float z =
 				(vptr[(i * 3) + 2] - srcmesh_cutmesh_com[2]) + pre_quantization_translation[2];
 			// insert our vertex into halfedge mesh
 			vd_t vd = halfedgeMesh.add_vertex(
@@ -140,9 +140,15 @@ bool client_input_arrays_to_hmesh(std::shared_ptr<context_t>& context_ptr,
 		// for each input mesh-vertex
 		for(McUint32 i = 0; i < numVertices; ++i)
 		{
-			const double& x = (vptr[(i * 3) + 0] - srcmesh_cutmesh_com[0]) + pre_quantization_translation[0];
-			const double& y = (vptr[(i * 3) + 1] - srcmesh_cutmesh_com[1]) + pre_quantization_translation[1];
-			const double& z = (vptr[(i * 3) + 2] - srcmesh_cutmesh_com[2]) + pre_quantization_translation[2];
+			const double x_ =
+				vptr[(i * 3) + 0];
+			const double y_ =
+				vptr[(i * 3) + 1];
+			const double z_ = vptr[(i * 3) + 2];
+
+			const double x = (x_ - srcmesh_cutmesh_com[0]) + pre_quantization_translation[0];
+			const double y = (y_ - srcmesh_cutmesh_com[1]) + pre_quantization_translation[1];
+			const double z = (z_ - srcmesh_cutmesh_com[2]) + pre_quantization_translation[2];
 
 #if MCUT_WITH_ARBITRARY_PRECISION_NUMBERS
 			vec3 quantized_vertex(scalar_t::quantize(x, multiplier),
@@ -2205,11 +2211,10 @@ bool calculate_vertex_parameters(
 	vec3_<double> srcmesh_cutmesh_bboxmin = compwise_min(srcmesh_bboxmin, cutmesh_bboxmin);
 	vec3_<double> srcmesh_cutmesh_bboxmax = compwise_max(srcmesh_bboxmax, cutmesh_bboxmax);
 
-	vec3_<double> offset_from_origin = vec3_<double>(
-		1.0,
-		1.0,
-		1.0); // ensure that when meshes are place into positive quadrant, no vertex coincides with the origin.
+	
 	vec3_<double> to_positive_quadrant = (srcmesh_cutmesh_com - srcmesh_cutmesh_bboxmin);
+	vec3_<double> offset_from_origin =
+		normalize(to_positive_quadrant); // ensures that when meshes are place into positive quadrant, no vertex coincides with the origin.
 
 	pre_quantization_translation = to_positive_quadrant + offset_from_origin;
 
@@ -2218,16 +2223,19 @@ bool calculate_vertex_parameters(
 	//
 	srcmesh_com = srcmesh_com + pre_quantization_translation;
 	cutmesh_com = cutmesh_com + pre_quantization_translation;
-	srcmesh_cutmesh_com = srcmesh_cutmesh_com + pre_quantization_translation;
+	//srcmesh_cutmesh_com = srcmesh_cutmesh_com  + pre_quantization_translation;
 	srcmesh_bboxmin = srcmesh_bboxmin + pre_quantization_translation;
 	srcmesh_bboxmax = srcmesh_bboxmax + pre_quantization_translation;
 	cutmesh_bboxmin = cutmesh_bboxmin + pre_quantization_translation;
 	cutmesh_bboxmax = cutmesh_bboxmax + pre_quantization_translation;
 	srcmesh_cutmesh_bboxmin = srcmesh_cutmesh_bboxmin + pre_quantization_translation;
 	srcmesh_cutmesh_bboxmax = srcmesh_cutmesh_bboxmax + pre_quantization_translation;
 
-
-	double max_coord = std::numeric_limits<double>::lowest();
+	vec3_<double> diag = srcmesh_cutmesh_bboxmax - srcmesh_cutmesh_bboxmin;
+	MCUT_ASSERT(diag[0] > 0);
+	MCUT_ASSERT(diag[1] > 0);
+	MCUT_ASSERT(diag[2] > 0);
+	/*double max_coord = std::numeric_limits<double>::lowest();
 	double min_coord = std::numeric_limits<double>::max();
 
 	for(int i = 0; i < 3; ++i)
@@ -2236,9 +2244,10 @@ bool calculate_vertex_parameters(
 							 std::min(srcmesh_cutmesh_bboxmin[1], srcmesh_cutmesh_bboxmin[2]));
 		max_coord = std::max(srcmesh_cutmesh_bboxmax[0],
 							 std::max(srcmesh_cutmesh_bboxmax[1], srcmesh_cutmesh_bboxmax[2]));
-	}
+	}*/
 
-	const double M = std::max(std::abs(min_coord), std::abs(max_coord));
+	const double M = std::max(diag[0],std::max(diag[1], diag[2])); 
+	/*Std::max(std::abs(min_coord), std::abs(max_coord));*/
 
 	auto is_pow2 = [](uint64_t x) { return (x != 0) && !(x & (x - 1)); };
 
@@ -2259,7 +2268,7 @@ bool calculate_vertex_parameters(
 	// The "+ 1" to cater to instances where "(uint64_t)(M + 0.5)" is a power-of-two: Here numerical perturbation will lead to 
 	// some vertex coordinates being larger than "(uint64_t)(M + 0.5)". Therefore we add 1 to cover even instances that involve perturbation.
 	const auto M_ = (uint64_t)(M + 0.5) + 1;
-	const auto M_np2 = is_pow2(M_+1) ? M_ : next_pow2(M_); 
+	const auto M_np2 = is_pow2(M_+1) ? M_ : next_pow2(M_+1); 
 
 	quantization_multiplier = (double)M_np2;
 

tests/source/benchmark.cpp

@@ -103,7 +103,11 @@ UTEST_I_TEARDOWN(Benchmark)
 
 UTEST_I(Benchmark, inputID, NUMBER_OF_BENCHMARKS)
 {
-	
+	/*if(utest_fixture->benchmarkIndex == 42 || utest_fixture->benchmarkIndex == 42)
+    {
+		return;
+    }*/
+
     std::vector<std::pair<std::string, std::string>> benchmarkMeshPairs;
 
     std::stringstream ss;

tests/source/degenerateInput.cpp

@@ -81,7 +81,7 @@ UTEST_F(DegenerateInput, edgeEdgeIntersection)
         MC_INVALID_OPERATION);
 }
 
-#if 0
+#if 1
 // An intersection between two triangles where a vertex from the cut-mesh triangle
 // lies on the src-mesh triangle. (This will only work with exact arith)
 UTEST_F(DegenerateInput, faceVertexIntersection)