Pass camera id into debug_viewer as a flag.
Now, we can match the intrinsics to the camera that the dataset was
captured with.
Change-Id: If8875939eda6126dd5b67f9a41481ffd1bea3260
diff --git a/y2019/vision/BUILD b/y2019/vision/BUILD
index 90c7dff..5cfc52b 100644
--- a/y2019/vision/BUILD
+++ b/y2019/vision/BUILD
@@ -74,7 +74,6 @@
gtk_dependent_cc_binary(
name = "debug_viewer",
srcs = ["debug_viewer.cc"],
- copts = ["-Wno-unused-variable"],
restricted_to = VISION_TARGETS,
deps = [
":target_finder",
@@ -83,6 +82,7 @@
"//aos/vision/blob:transpose",
"//aos/vision/debug:debug_framework",
"//aos/vision/math:vector",
+ "@com_github_gflags_gflags//:gflags",
],
)
diff --git a/y2019/vision/debug_viewer.cc b/y2019/vision/debug_viewer.cc
index fad0a0c..b282367 100644
--- a/y2019/vision/debug_viewer.cc
+++ b/y2019/vision/debug_viewer.cc
@@ -8,6 +8,7 @@
#include "aos/vision/blob/transpose.h"
#include "aos/vision/debug/debug_framework.h"
#include "aos/vision/math/vector.h"
+#include "gflags/gflags.h"
using aos::vision::ImageRange;
using aos::vision::ImageFormat;
@@ -18,6 +19,8 @@
using aos::vision::Segment;
using aos::vision::PixelRef;
+DEFINE_int32(camera, 10, "The camera to use the intrinsics for");
+
namespace y2019 {
namespace vision {
@@ -53,15 +56,18 @@
class FilterHarness : public aos::vision::FilterHarness {
public:
+ FilterHarness() {
+ *(target_finder_.mutable_intrinsics()) = GetCamera(FLAGS_camera)->intrinsics;
+ }
aos::vision::RangeImage Threshold(aos::vision::ImagePtr image) override {
- return finder_.Threshold(image);
+ return target_finder_.Threshold(image);
}
void InstallViewer(aos::vision::BlobStreamViewer *viewer) override {
viewer_ = viewer;
viewer_->SetScale(2.0);
overlays_.push_back(&overlay_);
- overlays_.push_back(finder_.GetOverlay());
+ overlays_.push_back(target_finder_.GetOverlay());
viewer_->view()->SetOverlays(&overlays_);
}
@@ -87,25 +93,25 @@
}
// Remove bad blobs.
- finder_.PreFilter(&imgs);
+ target_finder_.PreFilter(&imgs);
// Find polygons from blobs.
std::vector<std::vector<Segment<2>>> raw_polys;
for (const RangeImage &blob : imgs) {
// Convert blobs to contours in the corrected space.
- ContourNode* contour = finder_.GetContour(blob);
+ ContourNode *contour = target_finder_.GetContour(blob);
if (draw_contours_) {
DrawContour(contour, {255, 0, 0});
}
const ::std::vector<::Eigen::Vector2f> unwarped_contour =
- finder_.UnWarpContour(contour);
+ target_finder_.UnWarpContour(contour);
if (draw_contours_) {
DrawContour(unwarped_contour, {0, 0, 255});
}
// Process to polygons.
std::vector<Segment<2>> polygon =
- finder_.FillPolygon(unwarped_contour, draw_raw_poly_);
+ target_finder_.FillPolygon(unwarped_contour, draw_raw_poly_);
if (polygon.empty()) {
if (!draw_contours_) {
DrawBlob(blob, {255, 0, 0});
@@ -133,7 +139,7 @@
// Calculate each component side of a possible target.
std::vector<TargetComponent> target_component_list =
- finder_.FillTargetComponentList(raw_polys);
+ target_finder_.FillTargetComponentList(raw_polys);
if (draw_components_) {
for (const TargetComponent &comp : target_component_list) {
DrawComponent(comp, {0, 255, 255}, {0, 255, 255}, {255, 0, 0},
@@ -142,7 +148,7 @@
}
// Put the compenents together into targets.
- std::vector<Target> target_list = finder_.FindTargetsFromComponents(
+ std::vector<Target> target_list = target_finder_.FindTargetsFromComponents(
target_component_list, draw_raw_target_);
if (draw_raw_target_) {
for (const Target &target : target_list) {
@@ -153,12 +159,13 @@
// Use the solver to generate an intermediate version of our results.
std::vector<IntermediateResult> results;
for (const Target &target : target_list) {
- results.emplace_back(finder_.ProcessTargetToResult(target, draw_raw_IR_));
+ results.emplace_back(
+ target_finder_.ProcessTargetToResult(target, draw_raw_IR_));
if (draw_raw_IR_) DrawResult(results.back(), {255, 128, 0});
}
// Check that our current results match possible solutions.
- results = finder_.FilterResults(results, 0);
+ results = target_finder_.FilterResults(results, 0);
if (draw_results_) {
for (const IntermediateResult &res : results) {
DrawTarget(res, {0, 255, 0});
@@ -254,15 +261,15 @@
}
void DrawResult(const IntermediateResult &result, PixelRef color) {
- Target target =
- Project(finder_.GetTemplateTarget(), intrinsics(), result.extrinsics);
+ Target target = Project(target_finder_.GetTemplateTarget(), intrinsics(),
+ result.extrinsics);
DrawComponent(target.left, color, color, color, color);
DrawComponent(target.right, color, color, color, color);
}
void DrawTarget(const IntermediateResult &result, PixelRef color) {
- Target target =
- Project(finder_.GetTemplateTarget(), intrinsics(), result.extrinsics);
+ Target target = Project(target_finder_.GetTemplateTarget(), intrinsics(),
+ result.extrinsics);
Segment<2> leftAx((target.left.top + target.left.inside) * 0.5,
(target.left.bottom + target.left.outside) * 0.5);
leftAx.Set(leftAx.A() * 0.9 + leftAx.B() * 0.1,
@@ -293,11 +300,13 @@
overlay_.AddLine(p3 + leftAx.B(), p3 + rightAx.B(), {0, 255, 0});
}
- const IntrinsicParams &intrinsics() const { return finder_.intrinsics(); }
+ const IntrinsicParams &intrinsics() const {
+ return target_finder_.intrinsics();
+ }
private:
// implementation of the filter pipeline.
- TargetFinder finder_;
+ TargetFinder target_finder_;
aos::vision::BlobStreamViewer *viewer_ = nullptr;
aos::vision::PixelLinesOverlay overlay_;
std::vector<aos::vision::OverlayBase *> overlays_;
@@ -317,6 +326,7 @@
int main(int argc, char **argv) {
y2019::vision::FilterHarness filter_harness;
+ ::gflags::ParseCommandLineFlags(&argc, &argv, true);
aos::vision::DebugFrameworkMain(argc, argv, &filter_harness,
aos::vision::CameraParams());
}