Project import generated by Copybara.

GitOrigin-RevId: 9295f8ea2339edb71073695ed4fb3fded2f48c60

mediapipe/calculators/core/BUILD

@@ -606,6 +606,35 @@ cc_library(
     alwayslink = 1,
 )
 
+cc_library(
+    name = "packet_presence_calculator",
+    srcs = ["packet_presence_calculator.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework:packet",
+        "//mediapipe/framework:timestamp",
+        "//mediapipe/framework/port:status",
+    ],
+    alwayslink = 1,
+)
+
+cc_test(
+    name = "packet_presence_calculator_test",
+    srcs = ["packet_presence_calculator_test.cc"],
+    deps = [
+        ":gate_calculator",
+        ":packet_presence_calculator",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework:calculator_runner",
+        "//mediapipe/framework:timestamp",
+        "//mediapipe/framework/port:gtest_main",
+        "//mediapipe/framework/port:parse_text_proto",
+        "//mediapipe/framework/port:status",
+        "//mediapipe/framework/tool:sink",
+    ],
+)
+
 cc_library(
     name = "previous_loopback_calculator",
     srcs = ["previous_loopback_calculator.cc"],

mediapipe/calculators/core/packet_presence_calculator.cc

@@ -0,0 +1,84 @@
+// Copyright 2020 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/port/status.h"
+
+namespace mediapipe {
+
+// For each non empty input packet, emits a single output packet containing a
+// boolean value "true", "false" in response to empty packets (a.k.a. timestamp
+// bound updates) This can be used to "flag" the presence of an arbitrary packet
+// type as input into a downstream calculator.
+//
+// Inputs:
+//   PACKET - any type.
+//
+// Outputs:
+//   PRESENCE - bool.
+//     "true" if packet is not empty, "false" if there's timestamp bound update
+//     instead.
+//
+// Examples:
+// node: {
+//   calculator: "PacketPresenceCalculator"
+//   input_stream: "PACKET:packet"
+//   output_stream: "PRESENCE:presence"
+// }
+//
+// This calculator can be used in conjuction with GateCalculator in order to
+// allow/disallow processing. For instance:
+// node: {
+//   calculator: "PacketPresenceCalculator"
+//   input_stream: "PACKET:value"
+//   output_stream: "PRESENCE:disallow_if_present"
+// }
+// node {
+//   calculator: "GateCalculator"
+//   input_stream: "image"
+//   input_stream: "DISALLOW:disallow_if_present"
+//   output_stream: "image_for_processing"
+//   options: {
+//     [mediapipe.GateCalculatorOptions.ext] {
+//       empty_packets_as_allow: true
+//     }
+//   }
+// }
+class PacketPresenceCalculator : public CalculatorBase {
+ public:
+  static ::mediapipe::Status GetContract(CalculatorContract* cc) {
+    cc->Inputs().Tag("PACKET").SetAny();
+    cc->Outputs().Tag("PRESENCE").Set<bool>();
+    // Process() function is invoked in response to input stream timestamp
+    // bound updates.
+    cc->SetProcessTimestampBounds(true);
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Open(CalculatorContext* cc) override {
+    cc->SetOffset(TimestampDiff(0));
+    return ::mediapipe::OkStatus();
+  }
+
+  ::mediapipe::Status Process(CalculatorContext* cc) final {
+    cc->Outputs()
+        .Tag("PRESENCE")
+        .AddPacket(MakePacket<bool>(!cc->Inputs().Tag("PACKET").IsEmpty())
+                       .At(cc->InputTimestamp()));
+    return ::mediapipe::OkStatus();
+  }
+};
+REGISTER_CALCULATOR(PacketPresenceCalculator);
+
+}  // namespace mediapipe

mediapipe/calculators/core/packet_presence_calculator_test.cc

@@ -0,0 +1,85 @@
+// Copyright 2020 The MediaPipe Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/calculator_runner.h"
+#include "mediapipe/framework/port/gmock.h"
+#include "mediapipe/framework/port/gtest.h"
+#include "mediapipe/framework/port/parse_text_proto.h"
+#include "mediapipe/framework/port/status.h"
+#include "mediapipe/framework/port/status_matchers.h"
+#include "mediapipe/framework/timestamp.h"
+#include "mediapipe/framework/tool/sink.h"
+
+namespace mediapipe {
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using ::testing::Value;
+namespace {
+
+MATCHER_P2(BoolPacket, value, timestamp, "") {
+  return Value(arg.template Get<bool>(), Eq(value)) &&
+         Value(arg.Timestamp(), Eq(timestamp));
+}
+
+TEST(PreviousLoopbackCalculator, CorrectTimestamps) {
+  std::vector<Packet> output_packets;
+  CalculatorGraphConfig graph_config =
+      ParseTextProtoOrDie<CalculatorGraphConfig>(R"(
+        input_stream: 'allow'
+        input_stream: 'value'
+        node {
+          calculator: "GateCalculator"
+          input_stream: 'value'
+          input_stream: 'ALLOW:allow'
+          output_stream: 'gated_value'
+        }
+        node {
+          calculator: 'PacketPresenceCalculator'
+          input_stream: 'PACKET:gated_value'
+          output_stream: 'PRESENCE:presence'
+        }
+      )");
+  tool::AddVectorSink("presence", &graph_config, &output_packets);
+
+  CalculatorGraph graph;
+  MP_ASSERT_OK(graph.Initialize(graph_config, {}));
+  MP_ASSERT_OK(graph.StartRun({}));
+
+  auto send_packet = [&graph](int value, bool allow, Timestamp timestamp) {
+    MP_ASSERT_OK(graph.AddPacketToInputStream(
+        "value", MakePacket<int>(value).At(timestamp)));
+    MP_ASSERT_OK(graph.AddPacketToInputStream(
+        "allow", MakePacket<bool>(allow).At(timestamp)));
+  };
+
+  send_packet(10, false, Timestamp(10));
+  MP_EXPECT_OK(graph.WaitUntilIdle());
+  EXPECT_THAT(output_packets, ElementsAre(BoolPacket(false, Timestamp(10))));
+
+  output_packets.clear();
+  send_packet(20, true, Timestamp(11));
+  MP_EXPECT_OK(graph.WaitUntilIdle());
+  EXPECT_THAT(output_packets, ElementsAre(BoolPacket(true, Timestamp(11))));
+
+  MP_EXPECT_OK(graph.CloseAllInputStreams());
+  MP_EXPECT_OK(graph.WaitUntilDone());
+}
+
+}  // namespace
+}  // namespace mediapipe

mediapipe/calculators/tflite/tflite_inference_calculator.cc

@@ -201,7 +201,7 @@ int GetXnnpackNumThreads(
 //  Input tensors are assumed to be of the correct size and already normalized.
 //  All output TfLiteTensors will be destroyed when the graph closes,
 //  (i.e. after calling graph.WaitUntilDone()).
-//  GPU tensors are currently only supported on Android and iOS.
+//  GPU tensor support rquires OpenGL ES 3.1+.
 //  This calculator uses FixedSizeInputStreamHandler by default.
 //
 class TfLiteInferenceCalculator : public CalculatorBase {

mediapipe/calculators/util/BUILD

@@ -20,6 +20,24 @@ package(default_visibility = ["//visibility:public"])
 
 exports_files(["LICENSE"])
 
+cc_library(
+    name = "alignment_points_to_rects_calculator",
+    srcs = ["alignment_points_to_rects_calculator.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//mediapipe/calculators/util:detections_to_rects_calculator",
+        "//mediapipe/calculators/util:detections_to_rects_calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework:calculator_options_cc_proto",
+        "//mediapipe/framework/formats:detection_cc_proto",
+        "//mediapipe/framework/formats:location_data_cc_proto",
+        "//mediapipe/framework/formats:rect_cc_proto",
+        "//mediapipe/framework/port:ret_check",
+        "//mediapipe/framework/port:status",
+    ],
+    alwayslink = 1,
+)
+
 proto_library(
     name = "annotation_overlay_calculator_proto",
     srcs = ["annotation_overlay_calculator.proto"],
@@ -586,6 +604,15 @@ proto_library(
     ],
 )
 
+proto_library(
+    name = "rect_to_render_scale_calculator_proto",
+    srcs = ["rect_to_render_scale_calculator.proto"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//mediapipe/framework:calculator_proto",
+    ],
+)
+
 proto_library(
     name = "detections_to_render_data_calculator_proto",
     srcs = ["detections_to_render_data_calculator.proto"],
@@ -700,7 +727,15 @@ mediapipe_cc_proto_library(
     deps = [":rect_to_render_data_calculator_proto"],
 )
 
-# TODO: What is that one for?
+mediapipe_cc_proto_library(
+    name = "rect_to_render_scale_calculator_cc_proto",
+    srcs = ["rect_to_render_scale_calculator.proto"],
+    cc_deps = [
+        "//mediapipe/framework:calculator_cc_proto",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [":rect_to_render_scale_calculator_proto"],
+)
 
 mediapipe_cc_proto_library(
     name = "detections_to_render_data_calculator_cc_proto",
@@ -830,6 +865,19 @@ cc_library(
     alwayslink = 1,
 )
 
+cc_library(
+    name = "rect_to_render_scale_calculator",
+    srcs = ["rect_to_render_scale_calculator.cc"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":rect_to_render_scale_calculator_cc_proto",
+        "//mediapipe/framework:calculator_framework",
+        "//mediapipe/framework/formats:rect_cc_proto",
+        "//mediapipe/framework/port:ret_check",
+    ],
+    alwayslink = 1,
+)
+
 cc_test(
     name = "detections_to_render_data_calculator_test",
     size = "small",

mediapipe/calculators/util/alignment_points_to_rects_calculator.cc

@@ -0,0 +1,102 @@
+#include <cmath>
+
+#include "mediapipe/calculators/util/detections_to_rects_calculator.h"
+#include "mediapipe/calculators/util/detections_to_rects_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/calculator_options.pb.h"
+#include "mediapipe/framework/formats/detection.pb.h"
+#include "mediapipe/framework/formats/location_data.pb.h"
+#include "mediapipe/framework/formats/rect.pb.h"
+#include "mediapipe/framework/port/ret_check.h"
+#include "mediapipe/framework/port/status.h"
+
+namespace mediapipe {
+
+namespace {}  // namespace
+
+// A calculator that converts Detection with two alignment points to Rect.
+//
+// Detection should contain two points:
+//   * Center point - center of the crop
+//   * Scale point - vector from center to scale point defines size and rotation
+//       of the Rect. Not that Y coordinate of this vector is flipped before
+//       computing the rotation (it is caused by the fact that Y axis is
+//       directed downwards). So define target rotation vector accordingly.
+//
+// Example config:
+//   node {
+//     calculator: "AlignmentPointsRectsCalculator"
+//     input_stream: "DETECTIONS:detections"
+//     input_stream: "IMAGE_SIZE:image_size"
+//     output_stream: "NORM_RECT:rect"
+//     options: {
+//       [mediapipe.DetectionsToRectsCalculatorOptions.ext] {
+//         rotation_vector_start_keypoint_index: 0
+//         rotation_vector_end_keypoint_index: 1
+//         rotation_vector_target_angle_degrees: 90
+//         output_zero_rect_for_empty_detections: true
+//       }
+//     }
+//   }
+class AlignmentPointsRectsCalculator : public DetectionsToRectsCalculator {
+ public:
+  ::mediapipe::Status Open(CalculatorContext* cc) override {
+    RET_CHECK_OK(DetectionsToRectsCalculator::Open(cc));
+
+    // Make sure that start and end keypoints are provided.
+    // They are required for the rect size calculation and will also force base
+    // calculator to compute rotation.
+    options_ = cc->Options<DetectionsToRectsCalculatorOptions>();
+    RET_CHECK(options_.has_rotation_vector_start_keypoint_index())
+        << "Start keypoint is required to calculate rect size and rotation";
+    RET_CHECK(options_.has_rotation_vector_end_keypoint_index())
+        << "End keypoint is required to calculate rect size and rotation";
+
+    return ::mediapipe::OkStatus();
+  }
+
+ private:
+  ::mediapipe::Status DetectionToNormalizedRect(
+      const ::mediapipe::Detection& detection,
+      const DetectionSpec& detection_spec,
+      ::mediapipe::NormalizedRect* rect) override;
+};
+REGISTER_CALCULATOR(AlignmentPointsRectsCalculator);
+
+::mediapipe::Status AlignmentPointsRectsCalculator::DetectionToNormalizedRect(
+    const Detection& detection, const DetectionSpec& detection_spec,
+    NormalizedRect* rect) {
+  const auto& location_data = detection.location_data();
+  const auto& image_size = detection_spec.image_size;
+  RET_CHECK(image_size) << "Image size is required to calculate the rect";
+
+  const float x_center =
+      location_data.relative_keypoints(start_keypoint_index_).x() *
+      image_size->first;
+  const float y_center =
+      location_data.relative_keypoints(start_keypoint_index_).y() *
+      image_size->second;
+
+  const float x_scale =
+      location_data.relative_keypoints(end_keypoint_index_).x() *
+      image_size->first;
+  const float y_scale =
+      location_data.relative_keypoints(end_keypoint_index_).y() *
+      image_size->second;
+
+  // Bounding box size as double distance from center to scale point.
+  const float box_size =
+      std::sqrt((x_scale - x_center) * (x_scale - x_center) +
+                (y_scale - y_center) * (y_scale - y_center)) *
+      2.0;
+
+  // Set resulting bounding box.
+  rect->set_x_center(x_center / image_size->first);
+  rect->set_y_center(y_center / image_size->second);
+  rect->set_width(box_size / image_size->first);
+  rect->set_height(box_size / image_size->second);
+
+  return ::mediapipe::OkStatus();
+}
+
+}  // namespace mediapipe

mediapipe/calculators/util/rect_to_render_scale_calculator.cc

@@ -0,0 +1,111 @@
+#include "mediapipe/calculators/util/rect_to_render_scale_calculator.pb.h"
+#include "mediapipe/framework/calculator_framework.h"
+#include "mediapipe/framework/formats/rect.pb.h"
+
+namespace mediapipe {
+
+namespace {
+
+constexpr char kNormRectTag[] = "NORM_RECT";
+constexpr char kImageSizeTag[] = "IMAGE_SIZE";
+constexpr char kRenderScaleTag[] = "RENDER_SCALE";
+
+}  // namespace
+
+// A calculator to get scale for RenderData primitives.
+//
+// This calculator allows you to make RenderData primitives size (configured via
+// `thickness`) to depend on actual size of the object they should highlight
+// (e.g. pose, hand or face). It will give you bigger rendered primitives for
+// bigger/closer objects and smaller primitives for smaller/far objects.
+//
+// IMPORTANT NOTE: RenderData primitives are rendered via OpenCV, which accepts
+// only integer thickness. So when object goes further/closer you'll see 1 pixel
+// jumps.
+//
+// Check `mediapipe/util/render_data.proto` for details on
+// RenderData primitives and `thickness` parameter.
+//
+// Inputs:
+//   NORM_RECT: Normalized rectangle to compute object size from as maximum of
+//     width and height.
+//   IMAGE_SIZE: A std::pair<int, int> represention of image width and height to
+//     transform normalized object width and height to absolute pixel
+//     coordinates.
+//
+// Outputs:
+//   RENDER_SCALE: Float value that should be used to scale RenderData
+//     primitives calculated as `rect_size * multiplier`.
+//
+// Example config:
+//   node {
+//     calculator: "RectToRenderScaleCalculator"
+//     input_stream: "NORM_RECT:pose_landmarks_rect"
+//     input_stream: "IMAGE_SIZE:image_size"
+//     output_stream: "RENDER_SCALE:render_scale"
+//     options: {
+//       [mediapipe.RectToRenderScaleCalculatorOptions.ext] {
+//         multiplier: 0.001
+//       }
+//     }
+//   }
+class RectToRenderScaleCalculator : public CalculatorBase {
+ public:
+  static ::mediapipe::Status GetContract(CalculatorContract* cc);
+  ::mediapipe::Status Open(CalculatorContext* cc) override;
+  ::mediapipe::Status Process(CalculatorContext* cc) override;
+
+ private:
+  RectToRenderScaleCalculatorOptions options_;
+};
+REGISTER_CALCULATOR(RectToRenderScaleCalculator);
+
+::mediapipe::Status RectToRenderScaleCalculator::GetContract(
+    CalculatorContract* cc) {
+  cc->Inputs().Tag(kNormRectTag).Set<NormalizedRect>();
+  cc->Inputs().Tag(kImageSizeTag).Set<std::pair<int, int>>();
+  cc->Outputs().Tag(kRenderScaleTag).Set<float>();
+
+  return ::mediapipe::OkStatus();
+}
+
+::mediapipe::Status RectToRenderScaleCalculator::Open(CalculatorContext* cc) {
+  cc->SetOffset(TimestampDiff(0));
+  options_ = cc->Options<RectToRenderScaleCalculatorOptions>();
+
+  return ::mediapipe::OkStatus();
+}
+
+::mediapipe::Status RectToRenderScaleCalculator::Process(
+    CalculatorContext* cc) {
+  if (cc->Inputs().Tag(kNormRectTag).IsEmpty()) {
+    cc->Outputs()
+        .Tag(kRenderScaleTag)
+        .AddPacket(
+            MakePacket<float>(options_.multiplier()).At(cc->InputTimestamp()));
+    return ::mediapipe::OkStatus();
+  }
+
+  // Get image size.
+  int image_width;
+  int image_height;
+  std::tie(image_width, image_height) =
+      cc->Inputs().Tag(kImageSizeTag).Get<std::pair<int, int>>();
+
+  // Get rect size in absolute pixel coordinates.
+  const auto& rect = cc->Inputs().Tag(kNormRectTag).Get<NormalizedRect>();
+  const float rect_width = rect.width() * image_width;
+  const float rect_height = rect.height() * image_height;
+
+  // Calculate render scale.
+  const float rect_size = std::max(rect_width, rect_height);
+  const float render_scale = rect_size * options_.multiplier();
+
+  cc->Outputs()
+      .Tag(kRenderScaleTag)
+      .AddPacket(MakePacket<float>(render_scale).At(cc->InputTimestamp()));
+
+  return ::mediapipe::OkStatus();
+}
+
+}  // namespace mediapipe

mediapipe/calculators/util/rect_to_render_scale_calculator.proto

@@ -0,0 +1,18 @@
+syntax = "proto2";
+
+package mediapipe;
+
+import "mediapipe/framework/calculator.proto";
+
+message RectToRenderScaleCalculatorOptions {
+  extend CalculatorOptions {
+    optional RectToRenderScaleCalculatorOptions ext = 299463409;
+  }
+
+  // Multiplier to apply to the rect size.
+  // If one defined `thickness` for RenderData primitives for object (e.g. pose,
+  // hand or face) of size `A` then multiplier should be `1/A`. It means that
+  // when actual object size on the image will be `B`, than all RenderData
+  // primitives will be scaled with factor `B/A`.
+  optional float multiplier = 1 [default = 0.01];
+}

mediapipe/calculators/video/tracked_detection_manager_calculator.cc

@@ -197,90 +197,88 @@ REGISTER_CALCULATOR(TrackedDetectionManagerCalculator);
 
 ::mediapipe::Status TrackedDetectionManagerCalculator::Process(
     CalculatorContext* cc) {
-  if (cc->Inputs().HasTag("TRACKING_BOXES")) {
-    if (!cc->Inputs().Tag("TRACKING_BOXES").IsEmpty()) {
-      const TimedBoxProtoList& tracked_boxes =
-          cc->Inputs().Tag("TRACKING_BOXES").Get<TimedBoxProtoList>();
+  if (cc->Inputs().HasTag(kTrackingBoxesTag) &&
+      !cc->Inputs().Tag(kTrackingBoxesTag).IsEmpty()) {
+    const TimedBoxProtoList& tracked_boxes =
+        cc->Inputs().Tag(kTrackingBoxesTag).Get<TimedBoxProtoList>();
 
-      // Collect all detections that are removed.
-      auto removed_detection_ids = absl::make_unique<std::vector<int>>();
-      for (const TimedBoxProto& tracked_box : tracked_boxes.box()) {
-        NormalizedRect bounding_box;
-        bounding_box.set_x_center((tracked_box.left() + tracked_box.right()) /
-                                  2.f);
-        bounding_box.set_y_center((tracked_box.bottom() + tracked_box.top()) /
-                                  2.f);
-        bounding_box.set_height(tracked_box.bottom() - tracked_box.top());
-        bounding_box.set_width(tracked_box.right() - tracked_box.left());
-        bounding_box.set_rotation(tracked_box.rotation());
-        // First check if this box updates a detection that's waiting for
-        // update from the tracker.
-        auto waiting_for_update_detectoin_ptr =
-            waiting_for_update_detections_.find(tracked_box.id());
-        if (waiting_for_update_detectoin_ptr !=
-            waiting_for_update_detections_.end()) {
-          // Add the detection and remove duplicated detections.
-          auto removed_ids = tracked_detection_manager_.AddDetection(
-              std::move(waiting_for_update_detectoin_ptr->second));
-          MoveIds(removed_detection_ids.get(), std::move(removed_ids));
-
-          waiting_for_update_detections_.erase(
-              waiting_for_update_detectoin_ptr);
-        }
-        auto removed_ids = tracked_detection_manager_.UpdateDetectionLocation(
-            tracked_box.id(), bounding_box, tracked_box.time_msec());
+    // Collect all detections that are removed.
+    auto removed_detection_ids = absl::make_unique<std::vector<int>>();
+    for (const TimedBoxProto& tracked_box : tracked_boxes.box()) {
+      NormalizedRect bounding_box;
+      bounding_box.set_x_center((tracked_box.left() + tracked_box.right()) /
+                                2.f);
+      bounding_box.set_y_center((tracked_box.bottom() + tracked_box.top()) /
+                                2.f);
+      bounding_box.set_height(tracked_box.bottom() - tracked_box.top());
+      bounding_box.set_width(tracked_box.right() - tracked_box.left());
+      bounding_box.set_rotation(tracked_box.rotation());
+      // First check if this box updates a detection that's waiting for
+      // update from the tracker.
+      auto waiting_for_update_detectoin_ptr =
+          waiting_for_update_detections_.find(tracked_box.id());
+      if (waiting_for_update_detectoin_ptr !=
+          waiting_for_update_detections_.end()) {
+        // Add the detection and remove duplicated detections.
+        auto removed_ids = tracked_detection_manager_.AddDetection(
+            std::move(waiting_for_update_detectoin_ptr->second));
         MoveIds(removed_detection_ids.get(), std::move(removed_ids));
+
+        waiting_for_update_detections_.erase(waiting_for_update_detectoin_ptr);
       }
-      // TODO: Should be handled automatically in detection manager.
-      auto removed_ids = tracked_detection_manager_.RemoveObsoleteDetections(
-          GetInputTimestampMs(cc) - kDetectionUpdateTimeOutMS);
+      auto removed_ids = tracked_detection_manager_.UpdateDetectionLocation(
+          tracked_box.id(), bounding_box, tracked_box.time_msec());
       MoveIds(removed_detection_ids.get(), std::move(removed_ids));
+    }
+    // TODO: Should be handled automatically in detection manager.
+    auto removed_ids = tracked_detection_manager_.RemoveObsoleteDetections(
+        GetInputTimestampMs(cc) - kDetectionUpdateTimeOutMS);
+    MoveIds(removed_detection_ids.get(), std::move(removed_ids));
 
-      // TODO: Should be handled automatically in detection manager.
-      removed_ids = tracked_detection_manager_.RemoveOutOfViewDetections();
-      MoveIds(removed_detection_ids.get(), std::move(removed_ids));
+    // TODO: Should be handled automatically in detection manager.
+    removed_ids = tracked_detection_manager_.RemoveOutOfViewDetections();
+    MoveIds(removed_detection_ids.get(), std::move(removed_ids));
 
-      if (!removed_detection_ids->empty() &&
-          cc->Outputs().HasTag(kCancelObjectIdTag)) {
-        auto timestamp = cc->InputTimestamp();
-        for (int box_id : *removed_detection_ids) {
-          // The timestamp is incremented (by 1 us) because currently the box
-          // tracker calculator only accepts one cancel object ID for any given
-          // timestamp.
-          cc->Outputs()
-              .Tag(kCancelObjectIdTag)
-              .AddPacket(mediapipe::MakePacket<int>(box_id).At(timestamp++));
-        }
-      }
-
-      // Output detections and corresponding bounding boxes.
-      const auto& all_detections =
-          tracked_detection_manager_.GetAllTrackedDetections();
-      auto output_detections = absl::make_unique<std::vector<Detection>>();
-      auto output_boxes = absl::make_unique<std::vector<NormalizedRect>>();
-
-      for (const auto& detection_ptr : all_detections) {
-        const auto& detection = *detection_ptr.second;
-        // Only output detections that are synced.
-        if (detection.last_updated_timestamp() <
-            cc->InputTimestamp().Microseconds() / 1000) {
-          continue;
-        }
-        output_detections->emplace_back(
-            GetAxisAlignedDetectionFromTrackedDetection(detection));
-        output_boxes->emplace_back(detection.bounding_box());
-      }
-      if (cc->Outputs().HasTag(kDetectionsTag)) {
+    if (!removed_detection_ids->empty() &&
+        cc->Outputs().HasTag(kCancelObjectIdTag)) {
+      auto timestamp = cc->InputTimestamp();
+      for (int box_id : *removed_detection_ids) {
+        // The timestamp is incremented (by 1 us) because currently the box
+        // tracker calculator only accepts one cancel object ID for any given
+        // timestamp.
         cc->Outputs()
-            .Tag(kDetectionsTag)
-            .Add(output_detections.release(), cc->InputTimestamp());
+            .Tag(kCancelObjectIdTag)
+            .AddPacket(mediapipe::MakePacket<int>(box_id).At(timestamp++));
       }
+    }
 
-      if (cc->Outputs().HasTag(kDetectionBoxesTag)) {
-        cc->Outputs()
-            .Tag(kDetectionBoxesTag)
-            .Add(output_boxes.release(), cc->InputTimestamp());
+    // Output detections and corresponding bounding boxes.
+    const auto& all_detections =
+        tracked_detection_manager_.GetAllTrackedDetections();
+    auto output_detections = absl::make_unique<std::vector<Detection>>();
+    auto output_boxes = absl::make_unique<std::vector<NormalizedRect>>();
+
+    for (const auto& detection_ptr : all_detections) {
+      const auto& detection = *detection_ptr.second;
+      // Only output detections that are synced.
+      if (detection.last_updated_timestamp() <
+          cc->InputTimestamp().Microseconds() / 1000) {
+        continue;
       }
+      output_detections->emplace_back(
+          GetAxisAlignedDetectionFromTrackedDetection(detection));
+      output_boxes->emplace_back(detection.bounding_box());
+    }
+    if (cc->Outputs().HasTag(kDetectionsTag)) {
+      cc->Outputs()
+          .Tag(kDetectionsTag)
+          .Add(output_detections.release(), cc->InputTimestamp());
+    }
+
+    if (cc->Outputs().HasTag(kDetectionBoxesTag)) {
+      cc->Outputs()
+          .Tag(kDetectionBoxesTag)
+          .Add(output_boxes.release(), cc->InputTimestamp());
     }
   }