feat: Initial commit

Author: Dejan Trajkovic

README.md

@@ -0,0 +1,2 @@
+# Translate Python to C++
+In this project I applied my knowledge of C++ syntax by translating the Histogram Filter code from project 2 of 5 into C++.

a.out

@@ -0,0 +1,54 @@
+/**
+	debugging_helpers.cpp
+	
+	Purpose: helper functions for debugging when working
+	with grids of floats and chars.
+*/
+
+#include <vector>
+#include "debugging_helpers.h"
+
+using namespace std;
+
+/**
+    Displays a grid of beliefs. Does not return.
+
+    @param grid - a two dimensional grid (vector of 
+    	   vectors of floats) which will usually 
+    	   represent a robot's beliefs.
+*/
+void show_grid(vector < vector <float> > grid) {
+	int i, j;
+	float p;
+	vector<float> row;
+	for (i = 0; i < grid.size(); i++)
+	{
+		row = grid[i];
+		for (j=0; j< row.size(); j++)
+		{
+			p = row[j];	
+			cout << p << ' ';
+		}
+		cout << endl;
+	}
+}
+
+/**
+    Displays a grid map of the world
+*/
+void show_grid(vector < vector <char> > map) {
+	int i, j;
+	char p;
+	vector<char> row;
+	for (i = 0; i < map.size(); i++)
+	{
+		row = map[i];
+		for (j=0; j< row.size(); j++)
+		{
+			p = row[j];	
+			cout << p << ' ';
+		}
+		cout << endl;
+	}
+}
+

debugging_helpers.cpp

@@ -0,0 +1,12 @@
+#ifndef DEBUGGING_HELPERS_H
+#define DEBUGGING_HELPERS_H
+
+#include <vector>
+
+// Displays a grid of beliefs. Does not return.
+void show_grid(std::vector < std::vector <float> > grid);
+
+// Displays a grid map of the world
+void show_grid(std::vector < std::vector <char> > map);
+
+#endif /* DEBUGGING_HELPERS_H */

debugging_helpers.h

@@ -0,0 +1,277 @@
+/**
+	helpers.cpp
+
+	Purpose: helper functions which are useful when
+	implementing a 2-dimensional histogram filter.
+
+	This file is incomplete! Your job is to make the
+	normalize and blur functions work. Feel free to 
+	look at helper.py for working implementations 
+	which are written in python.
+*/
+
+#include <vector>
+#include <iostream>
+#include <cmath>
+#include <string>
+#include <fstream>
+#include "helpers.h"
+// #include "debugging_helpers.cpp"
+
+using namespace std;
+
+/**
+	TODO - implement this function
+
+    Normalizes a grid of numbers. 
+
+    @param grid - a two dimensional grid (vector of vectors of floats)
+		   where each entry represents the unnormalized probability 
+		   associated with that grid cell.
+
+    @return - a new normalized two dimensional grid where the sum of 
+    	   all probabilities is equal to one.
+*/
+vector< vector <float> > normalize(vector< vector <float> > grid) {
+	// todo - your code here
+	vector< vector <float> > newGrid;
+  	int height = grid.size();
+	int width = grid[0].size();
+	newGrid = zeros(height, width);
+    int total;
+    total = height*width;
+    for (int i = 0; i < grid.size(); i++) {
+        for (int j = 0; j < grid[i].size(); j++) {
+          newGrid[i][j] = grid[i][j] / total;
+          }
+    }
+  return newGrid;
+}
+
+/**
+	TODO - implement this function.
+
+    Blurs (and normalizes) a grid of probabilities by spreading 
+    probability from each cell over a 3x3 "window" of cells. This 
+    function assumes a cyclic world where probability "spills 
+    over" from the right edge to the left and bottom to top. 
+
+    EXAMPLE - After blurring (with blurring=0.12) a localized 
+    distribution like this:
+
+    0.00  0.00  0.00 
+    0.00  1.00  0.00
+    0.00  0.00  0.00 
+
+    would look like this:
+	
+	0.01  0.02	0.01
+	0.02  0.88	0.02
+	0.01  0.02  0.01
+
+    @param grid - a two dimensional grid (vector of vectors of floats)
+		   where each entry represents the unnormalized probability 
+		   associated with that grid cell.
+
+	@param blurring - a floating point number between 0.0 and 1.0 
+		   which represents how much probability from one cell 
+		   "spills over" to it's neighbors. If it's 0.0, then no
+		   blurring occurs. 
+
+    @return - a new normalized two dimensional grid where probability 
+    	   has been blurred.
+*/
+vector < vector <float> > blur(vector < vector < float> > grid, float blurring) {
+	// your code here
+	int height;
+    height = grid.size();
+    int width;
+    width  = grid[0].size();
+
+    float center_prob;
+    center_prob = 1.0-blurring;
+    float corner_prob;
+    corner_prob = blurring / 12.0;
+    float adjacent_prob;
+    adjacent_prob = blurring / 6.0;
+
+    vector < vector <float> > window;
+    vector<float> firstrow;
+    firstrow.push_back(corner_prob);
+    firstrow.push_back(adjacent_prob);
+    firstrow.push_back(corner_prob);
+    vector<float> secondrow;
+    secondrow.push_back(adjacent_prob);
+    secondrow.push_back(center_prob);
+    secondrow.push_back(adjacent_prob);
+    vector<float> thirdrow;
+    thirdrow.push_back(corner_prob);
+    thirdrow.push_back(adjacent_prob);
+    thirdrow.push_back(corner_prob);
+    window.push_back(firstrow);
+    window.push_back(secondrow);
+    window.push_back(thirdrow);
+    
+    vector < vector <float> > newGrid;
+    vector<float> singlerow (width,0.0);
+    for (int i = 0; i < height; i++) {
+        newGrid.push_back(singlerow);
+    }
+    for (int i = 0; i < height; i++) {
+        for (int j = 0; j < width; j++) {
+          float grid_val;
+          grid_val = grid[i][j];
+          for (int dx = -1; dx < 2; dx++) {
+            for (int dy = -1; dy < 2; dy++) {
+                float mult;
+                mult = window[dx+1][dy+1];
+                int new_i;
+              	int new_j;
+              	new_i = (((i + dy) % height) + height) % height;
+              	new_j = (((j + dx) % width) + width) % width;
+                newGrid[new_i][new_j] += mult * grid_val;
+              }
+          }
+        }
+    }
+  	return newGrid;
+}
+
+/** -----------------------------------------------
+#
+#
+#	You do not need to modify any code below here.
+#
+#
+# ------------------------------------------------- */
+
+
+/**
+    Determines when two grids of floating point numbers 
+    are "close enough" that they should be considered 
+    equal. Useful for battling "floating point errors".
+
+    @param g1 - a grid of floats
+    
+    @param g2 - a grid of floats
+
+    @return - A boolean (True or False) indicating whether
+    these grids are (True) or are not (False) equal.
+*/
+bool close_enough(vector < vector <float> > g1, vector < vector <float> > g2) {
+	int i, j;
+	float v1, v2;
+	if (g1.size() != g2.size()) {
+		return false;
+	}
+
+	if (g1[0].size() != g2[0].size()) {
+		return false;
+	}
+	for (i=0; i<g1.size(); i++) {
+		for (j=0; j<g1[0].size(); j++) {
+			v1 = g1[i][j];
+			v2 = g2[i][j];
+			if (abs(v2-v1) > 0.0001 ) {
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+bool close_enough(float v1, float v2) { 
+	if (abs(v2-v1) > 0.0001 ) {
+		return false;
+	} 
+	return true;
+}
+
+/**
+    Helper function for reading in map data
+
+    @param s - a string representing one line of map data.
+
+    @return - A row of chars, each of which represents the
+    color of a cell in a grid world.
+*/
+vector <char> read_line(string s) {
+	vector <char> row;
+
+	size_t pos = 0;
+	string token;
+	string delimiter = " ";
+	char cell;
+
+	while ((pos = s.find(delimiter)) != std::string::npos) {
+		token = s.substr(0, pos);
+		s.erase(0, pos + delimiter.length());
+
+		cell = token.at(0);
+		row.push_back(cell);
+	}
+
+	return row;
+}
+
+/**
+    Helper function for reading in map data
+
+    @param file_name - The filename where the map is stored.
+
+    @return - A grid of chars representing a map.
+*/
+vector < vector <char> > read_map(string file_name) {
+	ifstream infile(file_name);
+	vector < vector <char> > map;
+	if (infile.is_open()) {
+
+		char color;
+		vector <char> row;
+		
+		string line;
+
+		while (std::getline(infile, line)) {
+			row = read_line(line);
+			map.push_back(row);
+		}
+	}
+	return map;
+}
+
+/**
+    Creates a grid of zeros
+
+    For example:
+
+    zeros(2, 3) would return
+
+    0.0  0.0  0.0
+    0.0  0.0  0.0
+
+    @param height - the height of the desired grid
+
+    @param width - the width of the desired grid.
+
+    @return a grid of zeros (floats)
+*/
+vector < vector <float> > zeros(int height, int width) {
+	int i, j;
+	vector < vector <float> > newGrid;
+	vector <float> newRow;
+
+	for (i=0; i<height; i++) {
+		newRow.clear();
+		for (j=0; j<width; j++) {
+			newRow.push_back(0.0);
+		}
+		newGrid.push_back(newRow);
+	}
+	return newGrid;
+}
+
+// int main() {
+// 	vector < vector < char > > map = read_map("maps/m1.txt");
+// 	show_grid(map);
+// 	return 0;
+// }

helpers.cpp

@@ -0,0 +1,36 @@
+#ifndef HELPERS_H
+#define HELPERS_H
+
+#include <vector>
+#include <string>
+
+// Normalizes a grid of numbers. 
+std::vector< std::vector<float> > normalize(std::vector< std::vector <float> > grid);
+
+/** 
+	Blurs (and normalizes) a grid of probabilities by spreading 
+	probability from each cell over a 3x3 "window" of cells. This 
+	function assumes a cyclic world where probability "spills 
+	over" from the right edge to the left and bottom to top.
+*/
+std::vector < std::vector <float> > blur(std::vector < std::vector < float> > grid, float blurring);
+
+/**
+    Determines when two grids of floating point numbers 
+    are "close enough" that they should be considered 
+    equal. Useful for battling "floating point errors".
+*/
+bool close_enough(std::vector < std::vector <float> > g1, std::vector < std::vector <float> > g2);
+
+bool close_enough(float v1, float v2);
+
+// Helper function for reading in map data
+std::vector <char> read_line(std::string s);
+
+// Helper function for reading in map data
+std::vector < std::vector <char> > read_map(std::string file_name);
+
+// Creates a grid of zeros
+std::vector < std::vector <float> > zeros(int height, int width);
+
+#endif /* HELPERS_H */