Merge branch 'master' into ids

Author: aothms

.gitignore

@@ -30,3 +30,4 @@
 *.exe
 *.out
 *.app
+build/

CMakeLists.txt.in

@@ -5,7 +5,7 @@ project(googletest-download NONE)
 include(ExternalProject)
 ExternalProject_Add(googletest
   GIT_REPOSITORY    https://github.com/google/googletest.git
-  GIT_TAG           master
+  GIT_TAG           release-1.10.0
   SOURCE_DIR        "${CMAKE_BINARY_DIR}/googletest-src"
   BINARY_DIR        "${CMAKE_BINARY_DIR}/googletest-build"
   CONFIGURE_COMMAND ""

storage.h

@@ -1095,20 +1095,26 @@ class abstract_chunked_voxel_storage : public regular_voxel_storage {
 				release(get_chunk(this, ijk));
 			}
 
-			abstract_voxel_storage* a2 = a->is_explicit() ? a->copy(n->next_slot()) : a->make_explicit(n->next_slot());
+			abstract_voxel_storage* a_explicit = a->is_explicit() ? (inplace ? a : a->copy(n->next_slot())) : a->make_explicit(n->next_slot());
 			// b is temporary, so not assigned next_slot
-			abstract_voxel_storage* b2 = b->is_explicit() ? nullptr : b->make_explicit();
-			abstract_voxel_storage* b3 = b2 ? b2 : b;
+			abstract_voxel_storage* b_temp = b->is_explicit() ? nullptr : b->make_explicit();
+			abstract_voxel_storage* b_forced_explicit = b_temp ? b_temp : b;
 			if (mode == OP_UNION) {
-				a2->boolean_union(b3);
+				a_explicit->boolean_union(b_forced_explicit);
 			} else if (mode == OP_SUBTRACTION) {
-				a2->boolean_subtraction(b3);
+				a_explicit->boolean_subtraction(b_forced_explicit);
 			} else if (mode == OP_INTERSECTION) {
-				a2->boolean_intersection(b3);
+				a_explicit->boolean_intersection(b_forced_explicit);
 			}
-			delete b2;
-			set_chunk(n, ijk, a2);
+			delete b_temp;
 
+			if (inplace && a_explicit != a) {
+				delete a;
+			}
+			if (!inplace || a_explicit != a) {
+				set_chunk(n, ijk, a_explicit);
+			}			
+			
 		END_LOOP;
 
 		return n;

tests/test_validate.cpp

@@ -0,0 +1,90 @@
+#include "../voxelizer.h"
+#include "../volume.h"
+#include "../writer.h"
+#include "../traversal.h"
+
+#include <gtest/gtest.h>
+
+#include <BRepPrimAPI_MakeBox.hxx>
+#include <BRepMesh_IncrementalMesh.hxx>
+
+#include <ctime>
+
+namespace {
+	void voxelize(double vsize, bool rotated) {
+		auto storage = new chunked_voxel_storage<bit_t>(0., 0., 0., vsize, 10. / vsize, 10. / vsize, 10. / vsize, 32);
+
+		gp_Ax2 ax;
+		if (rotated) {
+			ax = gp_Ax2(gp_Pnt(3, 4, 4), gp_Dir(1, 1, 1));
+		} else {
+			ax = gp_Ax2(gp_Pnt(1, 1, 1), gp::DZ());
+		}
+
+		BRepPrimAPI_MakeBox mb(ax, 3., 3., 3.);
+		auto solid = mb.Solid();
+		BRepMesh_IncrementalMesh(solid, 0.001);
+
+		/*
+		TopExp_Explorer exp(solid, TopAbs_VERTEX);
+		std::set< std::tuple<double, double, double> > points;
+		for (; exp.More(); exp.Next()) {
+			gp_Pnt p = BRep_Tool::Pnt(TopoDS::Vertex(exp.Current()));
+			points.insert(std::make_tuple(p.X(), p.Y(), p.Z()));
+		}
+
+		for (auto& p : points) {
+			std::cout << std::get<0>(p) << " " << std::get<1>(p) << " " << std::get<2>(p) << std::endl;
+		}
+		*/
+
+		double t_vox, t_vol;
+
+		{
+			std::clock_t c_start = std::clock();
+			auto vox = voxelizer(solid, storage);
+			vox.Convert();
+			std::clock_t c_end = std::clock();
+
+			t_vox = (double) (c_end - c_start) / CLOCKS_PER_SEC;
+		}
+
+		/*
+		std::ofstream fs("rotated.obj");
+		storage->obj_export(fs);
+		*/
+		
+		regular_voxel_storage* volume;
+		{
+			std::clock_t c_start = std::clock();
+			traversal_voxel_filler_inverse filler;
+			volume = filler(storage);
+			std::clock_t c_end = std::clock();
+
+			t_vol = (double) (c_end - c_start) / CLOCKS_PER_SEC;
+		}
+
+
+		auto surface_count = storage->count();
+		auto volume_count = volume->count();
+
+		double total_volume = (volume_count + surface_count / 2) * (vsize * vsize * vsize);
+
+		std::cout << std::setprecision(15) << vsize << "," << rotated << "," << t_vol << "," << t_vox << "," << total_volume << std::endl; 
+
+		delete storage;
+		delete volume;
+	}
+}
+
+TEST(Validation, Volume) {
+	std::cout.precision(15);
+
+	for (int j = 1; j < 3; ++j) {
+		double b = 1. / std::pow(10, j);
+		for (int i = 1; i < 10; ++i) {
+			voxelize(b * i, false);
+			voxelize(b * i, true);
+		}
+	}
+}

tests/test_volume.cpp

@@ -146,4 +146,28 @@ TEST(Voxelizer, TraversalVolumeTripleSeparate) {
 
 	delete surface;
 	delete volume;
-}
+}
+
+TEST(Voxelizer, TraversalVolumeTripleInverted) {
+	auto surface = new chunked_voxel_storage<bit_t>(0., 0., 0., 0.1, 300, 100, 100, 32);
+
+	for (int i = 0; i < 3; ++i) {
+		BRepPrimAPI_MakeBox mb(gp_Pnt(i * 10. + 1., 1., 1.), 8., 8., 8.);
+		auto vox = voxelizer(mb.Solid(), surface);
+		vox.Convert();
+	}
+
+	// Traversal is done on external and then inverted
+	traversal_voxel_filler_inverse filler;
+	auto volume = filler(surface);
+	auto A = surface->count();
+	auto B = volume->count();
+
+	ASSERT_EQ(A, 3 * (81 * 81 * 2 + 81 * 79 * 2 + 79 * 79 * 2));
+	ASSERT_EQ(B, 3 * (79 * 79 * 79));
+	ASSERT_EQ(A + B, 3 * (81 * 81 * 81));
+
+	delete surface;
+	delete volume;
+}
+

traversal.h

@@ -421,6 +421,10 @@ class visitor {
 			queue.pop_front();
 		}
 	}
+
+	~visitor() {
+		delete visited_;
+	}
 };
 
 class query_leftmost {