changed obstacleRects and obstacleHash to shared_ptr for safer memory management

Author: brychanrobot

.vscode/settings.json

@@ -44,6 +44,9 @@
 		"*hpp*hpp*hpp*hppinitializer_list": "cpp",
 		"unordered_map": "cpp",
 		"unordered_set": "cpp",
-		"*hpp*hppcomplex": "cpp"
+		"*hpp*hppcomplex": "cpp",
+		"*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hpp*hppcstdarg": "cpp",
+		"*hrandom": "cpp",
+		"random": "cpp"
 	}
 }

SConstruct

@@ -1,10 +1,10 @@
-
 libs= ['m', 'GL', 'GLU', 'glfw',
 'X11', 'Xrandr', 'Xinerama', 'Xi', 'Xxf86vm', 'Xcursor',
 'pthread', 'dl', 'boost_system']
 
 
 env=Environment(CXXFLAGS='-Wall -march=native -std=c++14', LIBS=libs)
+
 debug = ARGUMENTS.get('debug', 0)
 if int(debug):
 	env.Append(CCFLAGS = '-g')

src/Waldo.hpp

@@ -11,9 +11,8 @@ class Waldo {
    private:
 	int width;
 	int height;
-	int mapArea;
-	std::vector<std::vector<bool>> *obstacleHash;
-	std::vector<std::shared_ptr<Rect>> *obstacleRects;
+	std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash;
+	std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects;
 	double maxTravel = 1;
 	std::thread replanThread;
 	int velocityHistorySize = 0;
@@ -69,7 +68,7 @@ class Waldo {
 	unsigned int importance = 0;
 	double distanceToUav = 0.0;
 
-	Waldo(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, int width, int height,
+	Waldo(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, int width, int height,
 	      int velocityHistorySize) {
 		this->obstacleHash = obstacleHash;
 		this->obstacleRects = obstacleRects;

src/generatePaths.cpp

@@ -77,7 +77,7 @@ int main(int argc, char* argv[]) {
 	bool usePseudoRandom = true;
 
 	AStar* planner = NULL;
-	vector<shared_ptr<Rect>> obstacleRects;
+	shared_ptr<vector<shared_ptr<Rect>>> obstacleRects;
 	vector<vector<bool>> obstacleHash;
 
 	for (int mapNum = 0; mapNum < 1000; mapNum++) {

src/generateTruth.cpp

@@ -84,7 +84,7 @@ int main(int argc, char* argv[]) {
 	options.parse(argc, argv);
 
 	for (int mapNum = 0; mapNum < numMaps; mapNum++) {
-		vector<shared_ptr<Rect>> obstacleRects;
+		shared_ptr<vector<shared_ptr<Rect>>> obstacleRects;
 		generateObstacleRects(width, height, 10, obstacleRects, OBSTACLE_PADDING);
 
 		vector<vector<bool>> obstacleHash(height, vector<bool>(width, false));

src/main.cpp

@@ -38,8 +38,8 @@ void drawWaldos(vector<unique_ptr<Waldo>>& waldos) {
 	}
 }
 
-void display(const shared_ptr<RrtNode> root, const shared_ptr<RrtNode>& endNode, deque<Coord>& bestPath, vector<shared_ptr<Rect>>* obstacleRects,
-             vector<unique_ptr<Waldo>>& waldos, bool shouldDrawTree) {
+void display(const shared_ptr<RrtNode> root, const shared_ptr<RrtNode>& endNode, deque<Coord>& bestPath,
+             shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, vector<unique_ptr<Waldo>>& waldos, bool shouldDrawTree) {
 	// drawPoint(root->coord, 10, HSL(25, 1.0, 0.5));
 	drawSolidCircle(root->coord, VIEW_RADIUS, HSL(25, 1.0, 0.5), 0.2);
 	drawHollowCircle(root->coord, VIEW_RADIUS, HSL(25, 1.0, 0.5));
@@ -93,23 +93,21 @@ int main(int argc, char* argv[]) {
 
 	auto window = initWindow(isFullscreen, monitorNum, width, height);
 
-	vector<shared_ptr<Rect>> obstacleRects;
-	generateObstacleRects(width, height, numObstacles, obstacleRects, OBSTACLE_PADDING);
+	auto obstacleRects = generateObstacleRects(width, height, numObstacles, OBSTACLE_PADDING);
 
-	vector<vector<bool>> obstacleHash(height, vector<bool>(width, false));
-	generateObstacleHash(obstacleRects, obstacleHash);
+	auto obstacleHash = generateObstacleHash(width, height, obstacleRects);
 
 	vector<unique_ptr<Waldo>> waldos;
 
 	for (int w = 0; w < numWaldos; w++) {
-		waldos.push_back(make_unique<Waldo>(&obstacleHash, &obstacleRects, width, height, waldoHistorySize));
+		waldos.push_back(make_unique<Waldo>(obstacleHash, obstacleRects, width, height, waldoHistorySize));
 	}
 
 	SamplingPlanner* planner;
 	if (useFmt) {
-		planner = new OnlineFmtStar(&obstacleHash, &obstacleRects, 6, width, height, !useHalton, nullptr, pruneRadius);
+		planner = new OnlineFmtStar(obstacleHash, obstacleRects, 6, width, height, !useHalton, nullptr, pruneRadius);
 	} else {
-		planner = new OnlineRrtStar(&obstacleHash, &obstacleRects, 6, width, height, !useHalton, nullptr, pruneRadius);
+		planner = new OnlineRrtStar(obstacleHash, obstacleRects, 6, width, height, !useHalton, nullptr, pruneRadius);
 	}
 	// AStar* planner = new AStar(&obstacleHash, &obstacleRects, width, height, usePseudoRandom);
 	// PrmStar* planner = new PrmStar(&obstacleHash, &obstacleRects, width, height, usePseudoRandom, GraphType::Grid);
@@ -133,7 +131,7 @@ int main(int argc, char* argv[]) {
 	auto moveInterval = 1.0 / 30.0;
 	auto score = 0.0;
 
-	auto remainderCallback = [&obstacleHash, &planner, &waldos, &replanInterval, &moveInterval, &trialLength, &startTime, &lastReplan, &lastMove,
+	auto remainderCallback = [obstacleHash, &planner, &waldos, &replanInterval, &moveInterval, &trialLength, &startTime, &lastReplan, &lastMove,
 	                          width, height, voteCellSize, &score, window, &lastPrint]() {
 		auto currentTime = glfwGetTime();
 
@@ -151,7 +149,7 @@ int main(int argc, char* argv[]) {
 				waldo->distanceToUav = euclideanDistance(planner->root->coord, waldo->coord());
 
 				if (waldo->importance > 0 && waldo->distanceToUav < VIEW_RADIUS) {
-					if (!lineIntersectsObstacles(waldo->coord(), planner->root->coord, &obstacleHash, width, height)) {
+					if (!lineIntersectsObstacles(waldo->coord(), planner->root->coord, obstacleHash, width, height)) {
 						score += waldo->importance;
 						vector<Coord> predictedCoords{
 						    // waldo->predictFutureFromRandWalk(60),

src/planning-utils

@@ -28,7 +28,7 @@ struct PriorityQueue {
 /////////////////////////////
 ////////////////////////////
 
-AStar::AStar(vector<vector<bool>> *obstacleHash, vector<shared_ptr<Rect>> *obstacleRects, int width, int height, bool usePseudoRandom,
+AStar::AStar(shared_ptr<vector<vector<bool>>> obstacleHash, shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, int width, int height, bool usePseudoRandom,
              bool initialize)
     : Planner(obstacleHash, obstacleRects, width, height, usePseudoRandom) {
 	this->name = "astar_visibility";

src/planning/AStar.cpp

@@ -15,7 +15,7 @@ class AStar : public Planner {
 	int dy;
 
    public:
-	AStar(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, int width, int height,
+	AStar(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, int width, int height,
 	      bool usePseudoRandom, bool initialize = true);
 	~AStar();
 	virtual void moveStart(double dx, double dy);

src/planning/AStar.hpp

@@ -6,7 +6,7 @@
 
 using namespace std;
 
-OnlineFmtStar::OnlineFmtStar(vector<vector<bool>> *obstacleHash, vector<shared_ptr<Rect>> *obstacleRects, double maxSegment, int width, int height,
+OnlineFmtStar::OnlineFmtStar(shared_ptr<vector<vector<bool>>> obstacleHash, shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, double maxSegment, int width, int height,
                              bool usePseudoRandom, shared_ptr<Coord> start, double pruneRadius, double percentCoverage)
     : SamplingPlanner(obstacleHash, obstacleRects, maxSegment, width, height, usePseudoRandom, start, pruneRadius, percentCoverage) {
 	this->name = "ofmtstar";

src/planning/OnlineFmtStar.cpp

@@ -15,7 +15,7 @@ class OnlineFmtStar : public SamplingPlanner {
 	void sampleAndAdd();
 
    public:
-	OnlineFmtStar(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, double maxSegment, int width,
+	OnlineFmtStar(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, double maxSegment, int width,
 	              int height, bool usePseudoRandom, std::shared_ptr<Coord> start, double pruneRadius = 5, double percentCoverage = 0.02);
 
 	bool isDoneBuilding();

src/planning/OnlineFmtStar.hpp

@@ -11,7 +11,7 @@
 
 using namespace std;
 
-OnlineRrtStar::OnlineRrtStar(vector<vector<bool>> *obstacleHash, vector<shared_ptr<Rect>> *obstacleRects, double maxSegment, int width, int height,
+OnlineRrtStar::OnlineRrtStar(shared_ptr<vector<vector<bool>>> obstacleHash, shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, double maxSegment, int width, int height,
                              bool usePseudoRandom, shared_ptr<Coord> start, double pruneRadius, double percentCoverage)
     : SamplingPlanner(obstacleHash, obstacleRects, maxSegment, width, height, usePseudoRandom, start, pruneRadius, percentCoverage) {
 	this->name = "orrtstar";

src/planning/OnlineRrtStar.cpp

@@ -9,7 +9,7 @@ class OnlineRrtStar : public SamplingPlanner {
 	void sampleAndAdd();
 
    public:
-	OnlineRrtStar(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, double maxSegment, int width,
+	OnlineRrtStar(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, double maxSegment, int width,
 	              int height, bool usePseudoRandom, std::shared_ptr<Coord> start, double pruneRadius = 5, double percentCoverage = 0.02);
 
 	bool isDoneBuilding();

src/planning/OnlineRrtStar.hpp

@@ -15,7 +15,7 @@
 
 using namespace std;
 
-Planner::Planner(vector<vector<bool>> *obstacleHash, vector<shared_ptr<Rect>> *obstacleRects, int width, int height, bool usePseudoRandom)
+Planner::Planner(shared_ptr<vector<vector<bool>>> obstacleHash, shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, int width, int height, bool usePseudoRandom)
     : haltonX(19), haltonY(31), rtree() {
 	// srand(time(NULL));  // initialize the random number generator so it happens
 

src/planning/Planner.cpp

@@ -25,7 +25,7 @@ class Planner {
 	int height;
 	double mapArea;
 	double obstacleArea;
-	std::vector<std::vector<bool>> *obstacleHash;
+	std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash;
 	double maxTravel = 1.5;
 	std::unordered_map<Coord, double> unseenAreaMap;
 
@@ -53,15 +53,15 @@ class Planner {
    public:
 	std::shared_ptr<RrtNode> root;
 	std::shared_ptr<RrtNode> endNode;
-	std::vector<std::shared_ptr<Rect>> *obstacleRects;
+	std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects;
 	std::deque<Coord> bestPath;
 	bool usePseudoRandom;
 	std::string name = "unset";
 
 	const double distanceK = 1.0;
 	double unseenAreaK = 100.0;
 
-	Planner(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, int width, int height,
+	Planner(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, int width, int height,
 	        bool usePseudoRandom);
 	virtual ~Planner();
 	virtual void moveStart(double dx, double dy);

src/planning/Planner.hpp

@@ -4,7 +4,7 @@
 
 using namespace std;
 
-PrmStar::PrmStar(vector<vector<bool>> *obstacleHash, vector<shared_ptr<Rect>> *obstacleRects, int width, int height, bool usePseudoRandom,
+PrmStar::PrmStar(shared_ptr<vector<vector<bool>>> obstacleHash, shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, int width, int height, bool usePseudoRandom,
                  GraphType graphType)
     : AStar(obstacleHash, obstacleRects, width, height, usePseudoRandom, false) {
 	if (graphType == GraphType::Random) {

src/planning/PrmStar.cpp

@@ -14,7 +14,7 @@ class PrmStar : public AStar {
 	GraphType graphType;
 
    public:
-	PrmStar(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, int width, int height,
+	PrmStar(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, int width, int height,
 	        bool usePseudoRandom, GraphType graphType);
 	~PrmStar();
 

src/planning/PrmStar.hpp

@@ -11,7 +11,7 @@
 
 using namespace std;
 
-SamplingPlanner::SamplingPlanner(vector<vector<bool>> *obstacleHash, vector<shared_ptr<Rect>> *obstacleRects, double maxSegment, int width,
+SamplingPlanner::SamplingPlanner(shared_ptr<vector<vector<bool>>> obstacleHash, shared_ptr<vector<shared_ptr<Rect>>> obstacleRects, double maxSegment, int width,
                                  int height, bool usePseudoRandom, shared_ptr<Coord> start, double pruneRadius, double percentCoverage)
     : Planner(obstacleHash, obstacleRects, width, height, usePseudoRandom) {
 	this->maxSegment = maxSegment;

src/planning/SamplingPlanner.cpp

@@ -30,7 +30,7 @@ class SamplingPlanner : public Planner {
 	int nodeAddThreshold;
 	long numNodes = 0;
 
-	SamplingPlanner(std::vector<std::vector<bool>> *obstacleHash, std::vector<std::shared_ptr<Rect>> *obstacleRects, double maxSegment, int width,
+	SamplingPlanner(std::shared_ptr<std::vector<std::vector<bool>>> obstacleHash, std::shared_ptr<std::vector<std::shared_ptr<Rect>>> obstacleRects, double maxSegment, int width,
 	                int height, bool usePseudoRandom, std::shared_ptr<Coord> start, double pruneRadius, double percentCoverage);
 	// virtual void sample() = 0;
 	virtual bool isDoneBuilding() = 0;

src/planning/SamplingPlanner.hpp

@@ -85,7 +85,7 @@ int main(int argc, char* argv[]) {
 	options.parse(argc, argv);
 
 	for (int mapNum = 0; mapNum < numMaps; mapNum++) {
-		vector<shared_ptr<Rect>> obstacleRects;
+		shared_ptr<vector<shared_ptr<Rect>>> obstacleRects;
 		// generateObstacleRects(width, height, 10, obstacleRects, OBSTACLE_PADDING);
 		readMap(string_format("data/map%d.json", mapNum), width, height, obstacleRects);
 

src/simulate.cpp

@@ -85,7 +85,7 @@ int main(int argc, char* argv[]) {
 	options.parse(argc, argv);
 
 	for (int mapNum = 0; mapNum < numMaps; mapNum++) {
-		vector<shared_ptr<Rect>> obstacleRects;
+		shared_ptr<vector<shared_ptr<Rect>>> obstacleRects;
 		// generateObstacleRects(width, height, 10, obstacleRects, OBSTACLE_PADDING);
 		readMap(string_format("data/map%d.json", mapNum), width, height, obstacleRects);
 		auto allPaths = readAllPaths(string_format("data/map%dpaths.json", mapNum));

src/simulate_tree.cpp

@@ -370,7 +370,7 @@ int main(int argc, char* argv[]) {
 	ratio = width / (float)height;
 	initDisplay(width, height, ratio);
 
-	vector<shared_ptr<Rect>> obstacleRects;
+	shared_ptr<vector<shared_ptr<Rect>>> obstacleRects;
 	generateObstacleRects(width, height, 10, obstacleRects);
 
 	vector<vector<bool>> obstacleHash(height, vector<bool>(width, false));