Added better tests for region initialisation

src/sb_pointcloud_processing/test/risk-analysis-test.cpp

@@ -10,60 +10,57 @@
 #include <RiskAnalysis.h>
 #include <gtest/gtest.h>
 
-/*
- * Function Prototype for Risk Analysis
- *
- * RiskAnalysis(float region_width, float region_height, int
- * num_vertical_cell_div,
- * int num_horizontal_cell_div, int region_min_points);
+pcl::PCLPointCloud2 empty_cloud = pcl::PCLPointCloud2();
+
+/**
+ * Runs tests to verify the inputted point_region has the proper dimensions specified
+ * by all the other inputs
  *
+ * @param point_region
+ * @param region_width
+ * @param region_height
+ * @param num_vertical_cell_divs
+ * @param num_horizontal_cell_divs
  */
-
-pcl::PCLPointCloud2 empty_cloud = pcl::PCLPointCloud2();
 void testRegionDimensions(std::vector<std::vector<RegionOfPoints>> point_region,
                           float region_width,
                           float region_height,
                           int num_vertical_cell_divs,
                           int num_horizontal_cell_divs);
 
-TEST(RegionCreation, DivisionsEqualToDimensions) {
-    float region_width           = 10;
-    float region_height          = 10;
-    int num_vertical_cell_divs   = 10;
-    int num_horizontal_cell_divs = 10;
-    int min_points_in_region     = 1;
-    float risk_multiplier = 1;
-    RiskAnalysis risk_analysis   = RiskAnalysis(region_width,
-                                              region_height,
-                                              num_vertical_cell_divs,
-                                              num_horizontal_cell_divs,
-                                              min_points_in_region,
-                                              risk_multiplier);
-
-    sb_geom_msgs::Polygon2D top_left_region =
-    risk_analysis.getRegionAreaFromIndices(0, 0);
-    EXPECT_FLOAT_EQ(region_height, top_left_region.points[0].x);
-    EXPECT_FLOAT_EQ(region_width / 2, top_left_region.points[0].y);
-
-    sb_geom_msgs::Polygon2D top_right_region =
-    risk_analysis.getRegionAreaFromIndices(0, 9);
-    EXPECT_FLOAT_EQ(region_height, top_right_region.points[1].x);
-    EXPECT_FLOAT_EQ(-region_width / 2, top_right_region.points[1].y);
-
-    sb_geom_msgs::Polygon2D bottom_right_region =
-    risk_analysis.getRegionAreaFromIndices(9, 9);
-    EXPECT_FLOAT_EQ(0, bottom_right_region.points[2].x);
-    EXPECT_FLOAT_EQ(-region_width / 2, bottom_right_region.points[2].y);
 
-    sb_geom_msgs::Polygon2D bottom_left_region =
-    risk_analysis.getRegionAreaFromIndices(9, 0);
-    EXPECT_FLOAT_EQ(0, bottom_left_region.points[3].x);
-    EXPECT_FLOAT_EQ(region_width / 2, bottom_left_region.points[3].y);
-
-    sb_geom_msgs::Polygon2D test_region =
-            risk_analysis.getRegionAreaFromIndices(2, 9);
+/**
+ *
+ * @param risk_analysis
+ * @param region_width
+ * @param region_height
+ * @param num_vertical_cell_divs
+ * @param num_horizontal_cell_divs
+ */
+void testRegionLocations(RiskAnalysis risk_analysis,
+                         float region_width,
+                         float region_height,
+                         int num_vertical_cell_divs,
+                         int num_horizontal_cell_divs);
+/**
+ * Runs tests to determine equality of points
+ */
+void EXPECT_POINT_EQ(sb_geom_msgs::Point2D expected_val, sb_geom_msgs::Point2D actual_val) {
+    float abs_error = 0.0001;
 
-    std::cout << risk_analysis.determineColumn(-4.5) << std::endl;
+    EXPECT_NEAR(expected_val.x, actual_val.x, abs_error);
+    EXPECT_NEAR(expected_val.y, actual_val.y, abs_error);
+}
+
+ /**
+  * Creates a point with specified values
+  */
+sb_geom_msgs::Point2D createPoint(float x, float y) {
+    sb_geom_msgs::Point2D point;
+    point.x = x;
+    point.y = y;
+
+    return point;
 }
 
 TEST(RegionInitialisation, DivisionsEqualToDimensions) {
@@ -92,6 +89,8 @@ TEST(RegionInitialisation, DivisionsEqualToDimensions) {
                          region_height,
                          num_vertical_cell_divs,
                          num_horizontal_cell_divs);
+
+    testRegionLocations(risk_analysis, region_width, region_height, num_vertical_cell_divs, num_horizontal_cell_divs);
 }
 
 TEST(RegionAnalysis, DivisionsEqualToDimensions) {
@@ -113,7 +112,7 @@ TEST(RegionAnalysis, DivisionsEqualToDimensions) {
     risk_analysis.assessPointCloudRisk(empty_cloud);
 }
 
-TEST(RegionCreation, NonIntegerCellDimensions) {
+TEST(RegionInitialisation, NonIntegerCellDimensions) {
     float region_width           = 10;
     float region_height          = 10;
     int num_vertical_cell_divs   = 100;
@@ -128,28 +127,20 @@ TEST(RegionCreation, NonIntegerCellDimensions) {
                                               min_points_in_region,
                                               risk_multiplier);
 
-    sb_geom_msgs::Polygon2D top_left_region =
-    risk_analysis.getRegionAreaFromIndices(0, 0);
-    EXPECT_FLOAT_EQ(region_height, top_left_region.points[0].x);
-    EXPECT_FLOAT_EQ(region_width / 2, top_left_region.points[0].y);
+    std::vector<std::vector<RegionOfPoints>> point_region;
 
-    sb_geom_msgs::Polygon2D top_right_region =
-    risk_analysis.getRegionAreaFromIndices(0, 99);
-    EXPECT_FLOAT_EQ(region_height, top_right_region.points[1].x);
-    EXPECT_FLOAT_EQ(-region_width / 2, top_right_region.points[1].y);
+    point_region = risk_analysis.initialisePointRegions();
 
-    sb_geom_msgs::Polygon2D bottom_right_region =
-    risk_analysis.getRegionAreaFromIndices(99, 99);
-    EXPECT_NEAR(0, bottom_right_region.points[2].x, 0.001);
-    EXPECT_FLOAT_EQ(-region_width / 2, bottom_right_region.points[2].y);
+    EXPECT_EQ(num_vertical_cell_divs, point_region.size());
+    EXPECT_EQ(num_horizontal_cell_divs, point_region[0].size());
 
-    sb_geom_msgs::Polygon2D bottom_left_region =
-    risk_analysis.getRegionAreaFromIndices(99, 0);
-    EXPECT_FLOAT_EQ(0, bottom_left_region.points[3].x);
-    EXPECT_FLOAT_EQ(region_width / 2, bottom_left_region.points[3].y);
+    testRegionDimensions(point_region,
+                         region_width,
+                         region_height,
+                         num_vertical_cell_divs,
+                         num_horizontal_cell_divs);
 
-    int row = risk_analysis.determineRow(2.8);
-    int col = risk_analysis.determineColumn(0);
+    testRegionLocations(risk_analysis, region_width, region_height, num_vertical_cell_divs, num_horizontal_cell_divs);
 
 }
 
@@ -172,6 +163,37 @@ TEST(RegionAnalysis, NonIntegerCellDimensions) {
     risk_analysis.assessPointCloudRisk(empty_cloud);
 }
 
+TEST(RegionInitialisation, OneDiv) {
+    float region_width           = 2;
+    float region_height          = 2;
+    int num_vertical_cell_divs   = 2;
+    int num_horizontal_cell_divs = 1;
+    int min_points_in_region     = -1;
+    float risk_multiplier = 1;
+
+    RiskAnalysis risk_analysis   = RiskAnalysis(region_width,
+                                                region_height,
+                                                num_vertical_cell_divs,
+                                                num_horizontal_cell_divs,
+                                                min_points_in_region,
+                                                risk_multiplier);
+
+    std::vector<std::vector<RegionOfPoints>> point_region;
+
+    point_region = risk_analysis.initialisePointRegions();
+
+    EXPECT_EQ(num_vertical_cell_divs, point_region.size());
+    EXPECT_EQ(num_horizontal_cell_divs, point_region[0].size());
+
+    testRegionDimensions(point_region,
+                         region_width,
+                         region_height,
+                         num_vertical_cell_divs,
+                         num_horizontal_cell_divs);
+
+    testRegionLocations(risk_analysis, region_width, region_height, num_vertical_cell_divs, num_horizontal_cell_divs);
+}
+
 TEST(RegionAnalysis, OneDiv) {
     float region_width           = 2;
     float region_height          = 2;
@@ -199,29 +221,58 @@ void testRegionDimensions(std::vector<std::vector<RegionOfPoints>> point_region,
     float cell_width  = region_width / num_horizontal_cell_divs;
     float cell_height = region_height / num_vertical_cell_divs;
 
+    float abs_error = 0.001;
     for (int i = 0; i < point_region.size(); i++) {
         for (int j = 0; j < point_region[0].size(); j++) {
             sb_geom_msgs::Polygon2D cur_cell = point_region[i][j].region_area;
 
             // Top Left Point vs Bottom Left Point
-            EXPECT_FLOAT_EQ(cell_height,
-                            cur_cell.points[0].x - cur_cell.points[3].x);
+            EXPECT_NEAR(cell_height, cur_cell.points[0].x - cur_cell.points[3].x, abs_error);
 
             // Top Right Point vs Bottom Right Point
-            EXPECT_FLOAT_EQ(cell_height,
-                            cur_cell.points[1].x - cur_cell.points[2].x);
+            EXPECT_NEAR(cell_height, cur_cell.points[1].x - cur_cell.points[2].x, abs_error);
 
             // Top Left Point vs Top Right Point
-            EXPECT_FLOAT_EQ(cell_width,
-                            cur_cell.points[0].y - cur_cell.points[1].y);
+            EXPECT_NEAR(cell_width, cur_cell.points[0].y - cur_cell.points[1].y, abs_error);
 
             // Bottom Left Point vs Bottom Right Point
-            EXPECT_FLOAT_EQ(cell_width,
-                            cur_cell.points[3].y - cur_cell.points[2].y);
+            EXPECT_NEAR(cell_width, cur_cell.points[3].y - cur_cell.points[2].y, abs_error);
         }
     }
 }
 
+void testRegionLocations(RiskAnalysis risk_analysis,
+                         float region_width,
+                         float region_height,
+                         int num_vertical_cell_divs,
+                         int num_horizontal_cell_divs) {
+    float cell_width  = region_width / num_horizontal_cell_divs;
+    float cell_height = region_height / num_vertical_cell_divs;
+
+    float cur_cell_top = region_height;
+    for (int i = 0; i < num_vertical_cell_divs; i++) {
+        float cur_cell_left = region_width / 2;
+
+        for (int j = 0; j < num_horizontal_cell_divs; j++) {
+            sb_geom_msgs::Polygon2D cur_region =
+                    risk_analysis.getRegionAreaFromIndices(i, j);
+
+            sb_geom_msgs::Point2D top_left_point = createPoint(cur_cell_top, cur_cell_left);
+            sb_geom_msgs::Point2D top_right_point = createPoint(cur_cell_top, cur_cell_left - cell_width);
+            sb_geom_msgs::Point2D bottom_right_point = createPoint(cur_cell_top - cell_height, cur_cell_left - cell_width);
+            sb_geom_msgs::Point2D bottom_left_point = createPoint(cur_cell_top - cell_height, cur_cell_left);
+
+            EXPECT_POINT_EQ(top_left_point, cur_region.points[0]);
+            EXPECT_POINT_EQ(top_right_point, cur_region.points[1]);
+            EXPECT_POINT_EQ(bottom_right_point, cur_region.points[2]);
+            EXPECT_POINT_EQ(bottom_left_point, cur_region.points[3]);
+            cur_cell_left -= cell_width;
+        }
+
+        cur_cell_top -= cell_height;
+    }
+}
+
 TEST(StandardDeviation, OneDataPoint) {
     RiskAnalysis risk_analysis = RiskAnalysis();