Download modules/gapi/src/backends/cpu/gcpuot.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 6.2 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/backends/cpu/gcpuot.cpp
- Command line
-
hf download hf://tgollogly/test/modules/gapi/src/backends/cpu/gcpuot.cpp
-
curl -L -o gcpuot.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/backends/cpu/gcpuot.cpp
6.2 kB
| // This file is part of OpenCV project. | |
| // It is subject to the license terms in the LICENSE file found in the top-level directory | |
| // of this distribution and at http://opencv.org/license.html. | |
| // | |
| // Copyright (C) 2023 Intel Corporation | |
| namespace cv | |
| { | |
| namespace gapi | |
| { | |
| namespace ot | |
| { | |
| // Helper functions for OT kernels | |
| namespace { | |
| void GTrackImplSetup(cv::GArrayDesc, cv::GArrayDesc, float, | |
| std::shared_ptr<vas::ot::ObjectTracker>& state, | |
| const ObjectTrackerParams& params) { | |
| vas::ot::ObjectTracker::Builder ot_builder; | |
| ot_builder.max_num_objects = params.max_num_objects; | |
| ot_builder.input_image_format = vas::ColorFormat(params.input_image_format); | |
| ot_builder.tracking_per_class = params.tracking_per_class; | |
| state = ot_builder.Build(vas::ot::TrackingType::ZERO_TERM_IMAGELESS); | |
| } | |
| void GTrackImplPrepare(const std::vector<cv::Rect>& in_rects, | |
| const std::vector<int32_t>& in_class_labels, | |
| float delta, | |
| std::vector<vas::ot::DetectedObject>& detected_objs, | |
| vas::ot::ObjectTracker& state) | |
| { | |
| if (in_rects.size() != in_class_labels.size()) | |
| { | |
| cv::util::throw_error(std::invalid_argument("Track() implementation run() method: in_rects and in_class_labels " | |
| "sizes are different.")); | |
| } | |
| detected_objs.reserve(in_rects.size()); | |
| for (std::size_t i = 0; i < in_rects.size(); ++i) | |
| { | |
| detected_objs.emplace_back(in_rects[i], in_class_labels[i]); | |
| } | |
| state.SetFrameDeltaTime(delta); | |
| } | |
| } // anonymous namespace | |
| GAPI_OCV_KERNEL_ST(GTrackFromMatImpl, cv::gapi::ot::GTrackFromMat, vas::ot::ObjectTracker) | |
| { | |
| static void setup(cv::GMatDesc, cv::GArrayDesc rects_desc, | |
| cv::GArrayDesc labels_desc, float delta, | |
| std::shared_ptr<vas::ot::ObjectTracker>& state, | |
| const cv::GCompileArgs& compile_args) | |
| { | |
| auto params = cv::gapi::getCompileArg<ObjectTrackerParams>(compile_args) | |
| .value_or(ObjectTrackerParams{}); | |
| GAPI_Assert(params.input_image_format == 0 && "Only BGR input as cv::GMat is supported for now"); | |
| GTrackImplSetup(rects_desc, labels_desc, delta, state, params); | |
| } | |
| static void run(const cv::Mat& in_mat, const std::vector<cv::Rect>& in_rects, | |
| const std::vector<int32_t>& in_class_labels, float delta, | |
| std::vector<cv::Rect>& out_tr_rects, | |
| std::vector<int32_t>& out_rects_classes, | |
| std::vector<uint64_t>& out_tr_ids, | |
| std::vector<int>& out_tr_statuses, | |
| vas::ot::ObjectTracker& state) | |
| { | |
| std::vector<vas::ot::DetectedObject> detected_objs; | |
| GTrackImplPrepare(in_rects, in_class_labels, delta, detected_objs, state); | |
| GAPI_Assert(in_mat.type() == CV_8UC3 && "Input mat is not in BGR format"); | |
| auto objects = state.Track(in_mat, detected_objs); | |
| for (auto&& object : objects) | |
| { | |
| out_tr_rects.push_back(object.rect); | |
| out_rects_classes.push_back(object.class_label); | |
| out_tr_ids.push_back(object.tracking_id); | |
| out_tr_statuses.push_back(static_cast<int>(object.status)); | |
| } | |
| } | |
| }; | |
| GAPI_OCV_KERNEL_ST(GTrackFromFrameImpl, cv::gapi::ot::GTrackFromFrame, vas::ot::ObjectTracker) | |
| { | |
| static void setup(cv::GFrameDesc, cv::GArrayDesc rects_desc, | |
| cv::GArrayDesc labels_desc, float delta, | |
| std::shared_ptr<vas::ot::ObjectTracker>& state, | |
| const cv::GCompileArgs& compile_args) | |
| { | |
| auto params = cv::gapi::getCompileArg<ObjectTrackerParams>(compile_args) | |
| .value_or(ObjectTrackerParams{}); | |
| GAPI_Assert(params.input_image_format == 1 && "Only NV12 input as cv::GFrame is supported for now"); | |
| GTrackImplSetup(rects_desc, labels_desc, delta, state, params); | |
| } | |
| static void run(const cv::MediaFrame& in_frame, const std::vector<cv::Rect>& in_rects, | |
| const std::vector<int32_t>& in_class_labels, float delta, | |
| std::vector<cv::Rect>& out_tr_rects, | |
| std::vector<int32_t>& out_rects_classes, | |
| std::vector<uint64_t>& out_tr_ids, | |
| std::vector<int>& out_tr_statuses, | |
| vas::ot::ObjectTracker& state) | |
| { | |
| std::vector<vas::ot::DetectedObject> detected_objs; | |
| GTrackImplPrepare(in_rects, in_class_labels, delta, detected_objs, state); | |
| // Extract metadata from MediaFrame and construct cv::Mat atop of it | |
| cv::MediaFrame::View view = in_frame.access(cv::MediaFrame::Access::R); | |
| auto ptrs = view.ptr; | |
| auto strides = view.stride; | |
| auto desc = in_frame.desc(); | |
| GAPI_Assert((desc.fmt == cv::MediaFormat::NV12 || desc.fmt == cv::MediaFormat::BGR) \ | |
| && "Input frame is not in NV12 or BGR format"); | |
| cv::Mat in; | |
| if (desc.fmt == cv::MediaFormat::NV12) { | |
| GAPI_Assert(ptrs[0] != nullptr && "Y plane pointer is empty"); | |
| GAPI_Assert(ptrs[1] != nullptr && "UV plane pointer is empty"); | |
| if (strides[0] > 0) { | |
| in = cv::Mat(desc.size, CV_8UC1, ptrs[0], strides[0]); | |
| } else { | |
| in = cv::Mat(desc.size, CV_8UC1, ptrs[0]); | |
| } | |
| } | |
| auto objects = state.Track(in, detected_objs); | |
| for (auto&& object : objects) | |
| { | |
| out_tr_rects.push_back(object.rect); | |
| out_rects_classes.push_back(object.class_label); | |
| out_tr_ids.push_back(object.tracking_id); | |
| out_tr_statuses.push_back(static_cast<int>(object.status)); | |
| } | |
| } | |
| }; | |
| cv::gapi::GKernelPackage cpu::kernels() | |
| { | |
| return cv::gapi::kernels | |
| < | |
| GTrackFromFrameImpl, | |
| GTrackFromMatImpl | |
| >(); | |
| } | |
| } // namespace ot | |
| } // namespace gapi | |
| } // namespace cv | |