Keep Placed Receivers Only

place_receivers/src/Geometry.cpp

@@ -104,21 +104,22 @@ struct Action {
     faceDist = faceNormal[0] * vertices[0].coords[0] + faceNormal[1] * vertices[0].coords[1] + faceNormal[2] * vertices[0].coords[2];
   }
 
-  double operator()(Point& receiver) {
+  void operator()(Receiver& receiver) {
     bool inside = true;
     for (unsigned side = 0; side < 3; ++side) {
-      inside = inside && (normals[side][0] * receiver.x + normals[side][1] * receiver.y <= dist[side]);
+      inside = inside && (normals[side][0] * receiver.point.x + normals[side][1] * receiver.point.y <= dist[side]);
     }
     if (inside) {
+      receiver.found = true;
       double local_depth = 0.0;
-      if (!std::isnan(receiver.z)) {
-        local_depth = std::max(depth, std::fabs(receiver.z));
+      if (!std::isnan(receiver.point.z)) {
+        local_depth = std::max(depth, std::fabs(receiver.point.z));
       }
-      receiver.z = (faceDist - faceNormal[0] * receiver.x - faceNormal[1] * receiver.y) / faceNormal[2];
+      receiver.point.z = (faceDist - faceNormal[0] * receiver.point.x - faceNormal[1] * receiver.point.y) / faceNormal[2];
       if (faceNormal[2] >= 0) {
-        receiver.z -= local_depth;
+        receiver.point.z -= local_depth;
       } else {
-        receiver.z += local_depth;
+        receiver.point.z += local_depth;
       }
     }
   }

place_receivers/src/KDTree.cpp

@@ -7,33 +7,31 @@
 KDTree::KDTree(std::vector<Point> const& points, int maxLeafSize)
 	: p(2), maxLeafN(maxLeafSize)
 {	
-	int n = points.size();
+	const auto n = points.size();
 
 	// Copy data and change row-major to column-major storage.
-	data = new Point[n];
-	memcpy(data, points.data(), n * sizeof(Point));
+	data.resize(n);
+	for (std::size_t i = 0; i < n; ++i) {
+		data[i].point.x = points[i].x;
+		data[i].point.y = points[i].y;
+		data[i].point.z = points[i].z;
+		data[i].found = false;
+	}
 
-	idx = new int[n];
+	idx.resize(n);
 	for (int i = 0; i < n; ++i) {
 		idx[i] = i;
 	}
 
 	int maxHeight = 1 + ceil(log2(n / static_cast<double>(maxLeafN)));
 	int maxNodes = (1 << maxHeight) - 1;
-	nodes = new Node[maxNodes];
+	nodes.resize(maxNodes);
 	nodes[0].start = 0;
 	nodes[0].n = n;
 
 	buildTree(0, 0);
 }
 
-KDTree::~KDTree()
-{
-	delete[] data;
-	delete[] idx;
-	delete[] nodes;
-}
-
 void KDTree::swap(int i, int j)
 {
 	if (i != j) {
@@ -44,10 +42,10 @@ void KDTree::swap(int i, int j)
 
 int KDTree::partition(int left, int right, int pivotIdx, int splitdim)
 {
-	double pivot = data[pivotIdx].coords[splitdim];
+	double pivot = data[pivotIdx].point.coords[splitdim];
 	int st = left;
 	for (int i = left; i < right; ++i) {
-		if (data[i].coords[splitdim] < pivot) {
+		if (data[i].point.coords[splitdim] < pivot) {
 			swap(st, i);
 			++st;
 		}
@@ -79,7 +77,7 @@ void KDTree::buildTree(int k, int splitdim)
 				}
 			}
 		}
-		node.pivot = data[median_idx].coords[splitdim];
+		node.pivot = data[median_idx].point.coords[splitdim];
 
 		Node& left = nodes[leftChild(k)];
 		left.start = node.start;

place_receivers/src/KDTree.h

@@ -51,18 +51,22 @@ union Point {
   };
 };
 
+struct Receiver {
+	Point point;
+	bool found{false};
+};
+
 class KDTree {
 public:
 	KDTree(std::vector<Point> const& points, int maxLeafSize);
-	~KDTree();
 
 	template<typename Support, typename Action>
-	void search(Support const& support, Action& action) const
+	void search(Support const& support, Action& action)
 	{
 		searchTree<Support, Action>(0, support, action);
 	}
 
-	inline Point const* points() const { return data; }
+	inline std::vector<Receiver> points() const { return data; }
 	inline int index(int r) const { return idx[r]; }
   inline int numPoints() const { return nodes[0].n;}
 
@@ -78,28 +82,28 @@ class KDTree {
 		int splitdim;
 		bool isLeaf;
 	};
-	Node* nodes;
+	std::vector<Node> nodes;
 
 	void swap(int i, int j);
 	int partition(int left, int right, int pivotIdx, int splitdim);
 	void buildTree(int k, int splitdim);
 
 	template<typename Support, typename Action>
-	void searchTree(int k, Support const& support, Action& action) const;
+	void searchTree(int k, Support const& support, Action& action);
 
-	Point* data;
-	int* idx;
+	std::vector<Receiver> data;
+	std::vector<int> idx;
 	int p;
 	int maxLeafN;
 };
 
 template<typename Support, typename Action>
-void KDTree::searchTree(int k, Support const& support, Action& action) const
+void KDTree::searchTree(int k, Support const& support, Action& action)
 {
-	Node& node = nodes[k];
+	const auto& node = nodes[k];
 	if (node.isLeaf) {
 		for (int i = node.start; i < node.start + node.n; ++i) {
-      action(data[i]);
+      		action(data[i]);
 		}
 	} else {
 		if (support(node.splitdim, 0) <= node.pivot) {

place_receivers/src/Reader.cpp

@@ -78,16 +78,16 @@ void writeReceiverFile(KDTree const& tree, std::string const& fileName) {
   out << std::scientific << std::setprecision(16);
 
   int failureCounter = 0;
-  Point const* points = tree.points();
-  std::vector<Point> sortedPoints(tree.numPoints());
+  const auto& receivers = tree.points();
+  std::vector<Receiver> sortedPoints(receivers.size());
   for (unsigned p = 0; p < tree.numPoints(); ++p) {
-    sortedPoints[tree.index(p)] = points[p];
+    sortedPoints[tree.index(p)] = receivers[p];
   }
-  for (auto const& point : sortedPoints) {
-    if (!std::isnan(point.z)) {
-      out << point.x << " " << point.y << " " << point.z << std::endl;
+  for (auto const& receiver : sortedPoints) {
+    if (!std::isnan(receiver.point.z) && receiver.found) {
+      out << receiver.point.x << " " << receiver.point.y << " " << receiver.point.z << std::endl;
     } else {
-      std::cerr << "Warning: Did not find elevation for receiver at (" << point.x << ", " << point.y << ")." << std::endl;
+      std::cerr << "Warning: Did not find elevation for receiver at (" << receiver.point.x << ", " << receiver.point.y << ")." << std::endl;
       ++failureCounter;
     }
   }

place_receivers/src/main.cpp

@@ -64,6 +64,11 @@ int main(int argc, char** argv)
 
   std::vector<Point> receivers = readReceiverFile(receiverFile);
   std::cout << "Read " << receivers.size() << " receivers." << std::endl;
+  if (receivers.empty()) {
+    std::cout << "No receivers found; nothing to do. Quitting." << std::endl;
+    return 0;
+  }
+
   KDTree tree(receivers, 1);
 
   Mesh mesh(meshFile);