[New] Added percentage linear error indicator rows cols

calibrators/intrinsic_camera_calibrator/intrinsic_camera_calibrator/intrinsic_camera_calibrator/board_detections/array_board_detection.py

@@ -62,36 +62,49 @@ def squared_error(p, p1, p2):
             p = p - p1
             p2 = p2 - p1
             p2 /= np.linalg.norm(p2)
-            return np.abs(np.power(np.linalg.norm(p), 2) - np.power(np.dot(p, p2), 2))
+            squared_distance = np.abs(np.power(np.linalg.norm(p), 2) - np.power(np.dot(p, p2), 2))
+            return squared_distance
 
-        if self._cached_linear_error_rows_rms is not None and self._cached_linear_error_cols_rms is not None:
+        if self._cached_linear_error_rows_rms is not None and \
+            self._cached_linear_error_cols_rms is not None:
             return self._cached_linear_error_rows_rms, self._cached_linear_error_cols_rms
 
-        error = 0
+        error_rows = 0
+        pct_err_rows = 0.0
 
         for j in range(self.rows):
             p1 = self.image_points[j, 0]
             p2 = self.image_points[j, -1]
+            points_dist = np.linalg.norm(p2 - p1)
 
             for i in range(1, self.cols - 1):
                 p = self.image_points[j, i]
-                error += squared_error(p, p1, p2)
+                sq_error = squared_error(p, p1, p2)
+                error_rows += sq_error
+                pct_err_rows += np.sqrt(sq_error) / points_dist
+
+        self._cached_linear_error_rows_rms = np.sqrt(error_rows / (self.rows * (self.cols - 2)))
+        pct_err_rows = pct_err_rows / (self.rows * (self.cols - 2))
 
-        self._cached_linear_error_rows_rms = np.sqrt(error / (self.rows * (self.cols - 2)))
-
         error_cols = 0
+        pct_err_cols = 0.0
 
         for j in range(self.cols):
             p1 = self.image_points[0, j]
             p2 = self.image_points[-1, j]
+            points_dist = np.linalg.norm(p2 - p1)
 
             for i in range(1, self.rows - 1):
                 p = self.image_points[i, j]
-                error_cols += squared_error(p, p1, p2)
+                sq_error = squared_error(p, p1, p2)
+                error_cols += sq_error
+                pct_err_cols += np.sqrt(sq_error) / points_dist
 
         self._cached_linear_error_cols_rms = np.sqrt(error_cols / (self.cols * (self.rows - 2)))
-
-        return self._cached_linear_error_rows_rms, self._cached_linear_error_cols_rms
+        pct_err_cols = pct_err_cols / (self.cols * (self.rows - 2))
+
+        return self._cached_linear_error_rows_rms, self._cached_linear_error_cols_rms, \
+                pct_err_rows, pct_err_cols
 
     def get_flattened_cell_sizes(self):
         if self._cached_flattened_cell_sizes is not None:

calibrators/intrinsic_camera_calibrator/intrinsic_camera_calibrator/intrinsic_camera_calibrator/camera_calibrator.py

@@ -879,6 +879,7 @@ def process_detection_results(self, img: np.array, detection: BoardDetection, im
                                                  self.data_collector.get_skew_percentage(),
                                                  self.data_collector.get_size_percentage(),
                                                  0, 0,
+                                                 0, 0,
                                                  self.indicators_alpha_spinbox.value(),
                                                  False)
 
@@ -947,7 +948,7 @@ def process_detection_results(self, img: np.array, detection: BoardDetection, im
             # self.raw_linear_error_rms_label.setText(
             #     f"Linear rows error rms: {detection.get_linear_error_rms():.2f} px"  # noqa E231
             # )
-            err_rms_rows, err_rms_cols = detection.get_linear_error_rms()
+            err_rms_rows, err_rms_cols, pct_err_rows, pct_err_cols = detection.get_linear_error_rms()
             self.raw_linear_error_rows_rms_label.setText(
                 f"Linear error rows rms:  {err_rms_rows:.2f} px"  # noqa E231
             )
@@ -992,6 +993,7 @@ def process_detection_results(self, img: np.array, detection: BoardDetection, im
                                                  self.data_collector.get_skew_percentage(),
                                                  self.data_collector.get_size_percentage(),
                                                  err_rms_rows, err_rms_cols,
+                                                 pct_err_rows, pct_err_cols,
                                                  self.indicators_alpha_spinbox.value(),
                                                  self.draw_indicators_checkbox.isChecked())
 

calibrators/intrinsic_camera_calibrator/intrinsic_camera_calibrator/intrinsic_camera_calibrator/views/image_view.py

@@ -206,6 +206,7 @@ def set_rendering_alpha(self, value: float):
     def set_draw_indicators(self, board_speed: float, max_allowed_board_speed: float,
                                 skew_percentage: float, board_size_percentage: float,
                                 rows_linear_error: float, cols_linear_error: float,
+                                pct_err_rows: float, pct_err_cols: float,
                                 alpha_indicators: float,
                                 value: bool):
         """Set values for the indicators."""
@@ -215,6 +216,8 @@ def set_draw_indicators(self, board_speed: float, max_allowed_board_speed: float
         self.board_size_percentage = board_size_percentage
         self.rows_linear_error = rows_linear_error
         self.cols_linear_error = cols_linear_error
+        self.pct_err_rows = pct_err_rows
+        self.pct_err_cols = pct_err_cols
         self.alpha_indicators = alpha_indicators 
         self.is_draw_indicators = value
 
@@ -280,11 +283,13 @@ def draw_indicators(self, painter: QPainter, display_size):
         painter.drawRect(board_size_indicator)
 
         # Draw Linear errors text
-        position_text_err_rows = QPointF(int(display_size.width() * .85), int(display_size.height() * .88))
-        painter.drawText(position_text_err_rows, "Err Rows " + str(round(self.rows_linear_error, 1)) + "px")
+        position_text_err_rows = QPointF(int(display_size.width() * .80), int(display_size.height() * .88))
+        painter.drawText(position_text_err_rows, "ErrRows " + str(round(self.rows_linear_error, 1)) + "px " + \
+                         str(round(self.pct_err_rows * 100, 1)) + "%")
 
-        position_text_err_cols = QPointF(int(display_size.width() * .85), int(display_size.height() * .93))
-        painter.drawText(position_text_err_cols, "Err Cols " + str(round(self.cols_linear_error, 1)) + "px")
+        position_text_err_cols = QPointF(int(display_size.width() * .80), int(display_size.height() * .93))
+        painter.drawText(position_text_err_cols, "ErrCols " + str(round(self.cols_linear_error, 1)) + "px " + \
+                         str(round(self.pct_err_cols *100, 1)) + "%")
 
     def pixmap(self) -> QPixmap:
         """Return the rendering QPixmap."""