| // 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 { | |
| /** | |
| * @brief This namespace contains G-API Operation Types for | |
| * VAS Object Tracking module functionality. | |
| */ | |
| namespace ot { | |
| /** | |
| * @enum TrackingStatus | |
| * | |
| * Tracking status twin for vas::ot::TrackingStatus | |
| */ | |
| enum TrackingStatus | |
| { | |
| NEW = 0, /**< The object is newly added. */ | |
| TRACKED, /**< The object is being tracked. */ | |
| LOST /**< The object gets lost now. The object can be tracked again | |
| by specifying detected object manually. */ | |
| }; | |
| struct GAPI_EXPORTS_W_SIMPLE ObjectTrackerParams | |
| { | |
| /** | |
| * Maximum number of trackable objects in a frame. | |
| * Valid range: 1 <= max_num_objects. Or it can be -1 if there is no limitation | |
| * of maximum number in X86. KMB/TBH has limitation up to 1024. | |
| * Default value is -1 which means there is no limitation in X86. KMB/TBH is -1 means 200. | |
| */ | |
| GAPI_PROP_RW int32_t max_num_objects = -1; | |
| /** | |
| * Input color format. Supports 0(BGR), 1(NV12), 2(BGRX) and 4(I420) | |
| */ | |
| GAPI_PROP_RW int32_t input_image_format = 0; | |
| /** | |
| * Specifies whether tracker to use detection class for keeping id of an object. | |
| * If it is true, new detection will be associated from previous tracking only when | |
| * those two have same class. | |
| * class id of an object is fixed across video frames. | |
| * If it is false, new detection can be associated across different-class objects. | |
| * In this case, the class id of an object may change across video frames depending on the tracker input. | |
| * It is recommended to turn this option off when it is likely that detector confuses the class of object. | |
| * For example, when detector confuses bicycle and motorbike. Turning this option off will increase | |
| * the tracking reliability as tracker will ignore the class label of detector. | |
| * @n | |
| * Default value is true. | |
| */ | |
| GAPI_PROP_RW bool tracking_per_class = true; | |
| bool operator==(const ObjectTrackerParams& other) const | |
| { | |
| return max_num_objects == other.max_num_objects | |
| && input_image_format == other.input_image_format | |
| && tracking_per_class == other.tracking_per_class; | |
| } | |
| }; | |
| using GTrackedInfo = std::tuple<cv::GArray<cv::Rect>, cv::GArray<int32_t>, cv::GArray<uint64_t>, cv::GArray<int>>; | |
| G_API_OP(GTrackFromMat, <GTrackedInfo(cv::GMat, cv::GArray<cv::Rect>, cv::GArray<int32_t>, float)>, "com.intel.track_from_mat") | |
| { | |
| static std::tuple<cv::GArrayDesc, cv::GArrayDesc, | |
| cv::GArrayDesc, cv::GArrayDesc> outMeta(cv::GMatDesc, cv::GArrayDesc, cv::GArrayDesc, float) | |
| { | |
| return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc(), | |
| cv::empty_array_desc(), cv::empty_array_desc()); | |
| } | |
| }; | |
| G_API_OP(GTrackFromFrame, <GTrackedInfo(cv::GFrame, cv::GArray<cv::Rect>, cv::GArray<int32_t>, float)>, "com.intel.track_from_frame") | |
| { | |
| static std::tuple<cv::GArrayDesc, cv::GArrayDesc, | |
| cv::GArrayDesc, cv::GArrayDesc> outMeta(cv::GFrameDesc, cv::GArrayDesc, cv::GArrayDesc, float) | |
| { | |
| return std::make_tuple(cv::empty_array_desc(), cv::empty_array_desc(), | |
| cv::empty_array_desc(), cv::empty_array_desc()); | |
| } | |
| }; | |
| /** | |
| * @brief Tracks objects with video frames. | |
| * If a detected object is overlapped enough with one of tracked object, the tracked object's | |
| * informationis updated with the input detected object. | |
| * On the other hand, if a detected object is overlapped with none of tracked objects, | |
| * the detected object is newly added and ObjectTracker starts to track the object. | |
| * In zero term tracking type, ObjectTracker clears tracked objects in case that empty | |
| * list of detected objects is passed in. | |
| * | |
| * @param mat Input frame. | |
| * @param detected_rects Detected objects rectangles in the input frame. | |
| * @param detected_class_labels Detected objects class labels in the input frame. | |
| * @param delta Frame_delta_t Delta time between two consecutive tracking in seconds. | |
| * The valid range is [0.005 ~ 0.5]. | |
| * @return Tracking results of target objects. | |
| * cv::GArray<cv::Rect> Array of rectangles for tracked objects. | |
| * cv::GArray<int32_t> Array of detected objects labels. | |
| * cv::GArray<uint64_t> Array of tracking IDs for objects. | |
| * Numbering sequence starts from 1. | |
| * The value 0 means the tracking ID of this object has | |
| * not been assigned. | |
| * cv::GArray<int> Array of tracking statuses for objects. | |
| */ | |
| GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>, | |
| cv::GArray<int>, | |
| cv::GArray<uint64_t>, | |
| cv::GArray<int>> | |
| track(const cv::GMat& mat, | |
| const cv::GArray<cv::Rect>& detected_rects, | |
| const cv::GArray<int>& detected_class_labels, | |
| float delta); | |
| /** | |
| @overload | |
| * @brief Tracks objects with video frames. Overload of track(...) for frame as GFrame. | |
| * | |
| * @param frame Input frame. | |
| * @param detected_rects Detected objects rectangles in the input frame. | |
| * @param detected_class_labels Detected objects class labels in the input frame. | |
| * @param delta Frame_delta_t Delta time between two consecutive tracking in seconds. | |
| * The valid range is [0.005 ~ 0.5]. | |
| * @return Tracking results of target objects. | |
| * @return Tracking results of target objects. | |
| * cv::GArray<cv::Rect> Array of rectangles for tracked objects. | |
| * cv::GArray<int32_t> Array of detected objects labels. | |
| * cv::GArray<uint64_t> Array of tracking IDs for objects. | |
| * Numbering sequence starts from 1. | |
| * The value 0 means the tracking ID of this object has | |
| * not been assigned. | |
| * cv::GArray<int> Array of tracking statuses for objects. | |
| */ | |
| GAPI_EXPORTS_W std::tuple<cv::GArray<cv::Rect>, | |
| cv::GArray<int>, | |
| cv::GArray<uint64_t>, | |
| cv::GArray<int>> | |
| track(const cv::GFrame& frame, | |
| const cv::GArray<cv::Rect>& detected_rects, | |
| const cv::GArray<int>& detected_class_labels, | |
| float delta); | |
| } // namespace ot | |
| } // namespace gapi | |
| } // namespace cv | |
| // FIXME: move to a separate file? | |
| namespace cv | |
| { | |
| namespace detail | |
| { | |
| template<> struct CompileArgTag<cv::gapi::ot::ObjectTrackerParams> | |
| { | |
| static const char* tag() | |
| { | |
| return "cv.gapi.ot.object_tracker_params"; | |
| } | |
| }; | |
| } // namespace detail | |
| namespace gapi | |
| { | |
| namespace s11n | |
| { | |
| namespace detail | |
| { | |
| template<> struct S11N<cv::gapi::ot::ObjectTrackerParams> { | |
| static void serialize(IOStream &os, const cv::gapi::ot::ObjectTrackerParams &p) { | |
| os << p. max_num_objects << p.input_image_format << p.tracking_per_class; | |
| } | |
| static cv::gapi::ot::ObjectTrackerParams deserialize(IIStream &is) { | |
| cv::gapi::ot::ObjectTrackerParams p; | |
| is >> p. max_num_objects >> p.input_image_format >> p.tracking_per_class; | |
| return p; | |
| } | |
| }; | |
| } // namespace detail | |
| } // namespace s11n | |
| } // namespace gapi | |
| } // namespace cv | |