commit d73ee8e3729b906d32c3355b5550ef5f04ef3cc3
author Philipp Schrader <philipp.schrader+971@gmail.com> Mon Mar 14 21:55:47 2022 -0700
committer Gerrit Code Review <gerrit@software.frc971.org> Mon Mar 14 21:55:47 2022 -0700
tree cb689fe94462d9da0ad7517ddcf88814d69568c6
parent 41f85e8557374d00a99975f9c6b592a6d9d681c7
parent b48f8eaa6abf099d852d1f1b75e91e49c811d62b

Merge "Fix flakiness of //scouting:scouting_test"

y2022/localizer/localizer.cc

diff --git a/y2022/localizer/localizer.cc b/y2022/localizer/localizer.cc
index e75c014..ff3a181 100644
--- a/y2022/localizer/localizer.cc
+++ b/y2022/localizer/localizer.cc
@@ -885,6 +885,7 @@
       zeroer_(zeroing::ImuZeroer::FaultBehavior::kTemporary),
       left_encoder_(-DrivetrainWrapPeriod() / 2.0, DrivetrainWrapPeriod()),
       right_encoder_(-DrivetrainWrapPeriod() / 2.0, DrivetrainWrapPeriod()) {
+  event_loop->SetRuntimeRealtimePriority(40);
   event_loop_->MakeWatcher(
       "/drivetrain",
       [this](

y2022/vision/blob_detector.cc

diff --git a/y2022/vision/blob_detector.cc b/y2022/vision/blob_detector.cc
index 873cf43..4aa453c 100644
--- a/y2022/vision/blob_detector.cc
+++ b/y2022/vision/blob_detector.cc
@@ -11,40 +11,26 @@
 #include "opencv2/imgproc.hpp"
 #include "y2022/vision/geometry.h"
 
-DEFINE_uint64(red_delta, 100,
-              "Required difference between green pixels vs. red");
-DEFINE_uint64(blue_delta, 1,
-              "Required difference between green pixels vs. blue");
-
-DEFINE_bool(use_outdoors, false,
-            "If true, change thresholds to handle outdoor illumination");
-DEFINE_uint64(outdoors_red_delta, 100,
-              "Difference between green pixels vs. red, when outdoors");
-DEFINE_uint64(outdoors_blue_delta, 1,
-              "Difference between green pixels vs. blue, when outdoors");
+DEFINE_int32(red_delta, 100,
+             "Required difference between green pixels vs. red");
+DEFINE_int32(blue_delta, -10,
+             "Required difference between green pixels vs. blue");
 
 namespace y2022 {
 namespace vision {
 
 cv::Mat BlobDetector::ThresholdImage(cv::Mat bgr_image) {
-  size_t red_delta = FLAGS_red_delta;
-  size_t blue_delta = FLAGS_blue_delta;
-
-  if (FLAGS_use_outdoors) {
-    red_delta = FLAGS_outdoors_red_delta;
-    blue_delta = FLAGS_outdoors_blue_delta;
-  }
-
   cv::Mat binarized_image(cv::Size(bgr_image.cols, bgr_image.rows), CV_8UC1);
   for (int row = 0; row < bgr_image.rows; row++) {
     for (int col = 0; col < bgr_image.cols; col++) {
       cv::Vec3b pixel = bgr_image.at<cv::Vec3b>(row, col);
-      uint8_t blue = pixel.val[0];
-      uint8_t green = pixel.val[1];
-      uint8_t red = pixel.val[2];
+      int blue = pixel.val[0];
+      int green = pixel.val[1];
+      int red = pixel.val[2];
       // Simple filter that looks for green pixels sufficiently brigher than
       // red and blue
-      if ((green > blue + blue_delta) && (green > red + red_delta)) {
+      if ((green > blue + FLAGS_blue_delta) &&
+          (green > red + FLAGS_red_delta)) {
         binarized_image.at<uint8_t>(row, col) = 255;
       } else {
         binarized_image.at<uint8_t>(row, col) = 0;

y2022/vision/viewer.cc

diff --git a/y2022/vision/viewer.cc b/y2022/vision/viewer.cc
index f847dbd..f99cf97 100644
--- a/y2022/vision/viewer.cc
+++ b/y2022/vision/viewer.cc
@@ -203,10 +203,13 @@
   cv::Mat intrinsics;
   intrinsics_float.convertTo(intrinsics, CV_64F);
 
-  const auto extrinsics_float =
-      cv::Mat(4, 4, CV_32F,
-              const_cast<void *>(static_cast<const void *>(
-                  calibration->fixed_extrinsics()->data()->data())));
+  const frc971::vision::calibration::TransformationMatrix *transform =
+      calibration->has_turret_extrinsics() ? calibration->turret_extrinsics()
+                                           : calibration->fixed_extrinsics();
+
+  const auto extrinsics_float = cv::Mat(
+      4, 4, CV_32F,
+      const_cast<void *>(static_cast<const void *>(transform->data()->data())));
   cv::Mat extrinsics;
   extrinsics_float.convertTo(extrinsics, CV_64F);