195 lines
8.2 KiB
C++
195 lines
8.2 KiB
C++
// 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
|
|
|
|
#ifndef OPENCV_GAPI_OT_HPP
|
|
#define OPENCV_GAPI_OT_HPP
|
|
|
|
#include <opencv2/gapi.hpp>
|
|
#include <opencv2/gapi/s11n.hpp>
|
|
#include <opencv2/gapi/gkernel.hpp>
|
|
|
|
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
|
|
|
|
#endif // OPENCV_GAPI_OT_HPP
|