diff --git a/src/core/include/openvino/core/dimension.hpp b/src/core/include/openvino/core/dimension.hpp index c4963075e47..cde49b73126 100644 --- a/src/core/include/openvino/core/dimension.hpp +++ b/src/core/include/openvino/core/dimension.hpp @@ -20,6 +20,7 @@ class TableOfEquivalence; /// /// Static dimensions may be implicitly converted from value_type. A dynamic dimension is /// constructed with Dimension() or Dimension::dynamic(). +/// \ingroup ov_model_cpp_api class OPENVINO_API Dimension { public: using value_type = int64_t; diff --git a/src/core/include/openvino/core/extension.hpp b/src/core/include/openvino/core/extension.hpp index 63e8db17051..c40ea0b7c0b 100644 --- a/src/core/include/openvino/core/extension.hpp +++ b/src/core/include/openvino/core/extension.hpp @@ -26,6 +26,7 @@ class Extension; /** * @brief The class provides the base interface for OpenVINO extensions + * @ingroup ov_model_cpp_api */ class OPENVINO_API Extension { public: diff --git a/src/core/include/openvino/core/graph_util.hpp b/src/core/include/openvino/core/graph_util.hpp index edb88b265c6..73c1986a7a1 100644 --- a/src/core/include/openvino/core/graph_util.hpp +++ b/src/core/include/openvino/core/graph_util.hpp @@ -263,12 +263,13 @@ std::vector> topological_sort(T root_nodes) { // NodeMap input may contain default node mapping i.e. pre-cloned nodes // NodeMap output (by reference) fully maps input and cloned Model ops OPENVINO_API -std::shared_ptr clone_model(const ov::Model& func, +std::shared_ptr clone_model(const ov::Model& model, std::unordered_map>& node_map); -// input model is cloned and returned +/// \brief input model is cloned and returned +/// \ingroup ov_model_cpp_api OPENVINO_API -std::shared_ptr clone_model(const ov::Model& func); +std::shared_ptr clone_model(const ov::Model& model); OPENVINO_API bool compare_constants(const std::shared_ptr& n1, const std::shared_ptr& n2); diff --git a/src/core/include/openvino/core/layout.hpp b/src/core/include/openvino/core/layout.hpp index 12135cefb1a..ab0fc2296df 100644 --- a/src/core/include/openvino/core/layout.hpp +++ b/src/core/include/openvino/core/layout.hpp @@ -16,6 +16,13 @@ namespace ov { +/** + * @defgroup ov_layout_cpp_api Layout + * @ingroup ov_model_cpp_api + * OpenVINO Layout API to work and configure layouts for ov::Model inputs or outputs + * + */ + /// \brief ov::Layout represents the text information of tensor's dimensions/axes. E.g. layout `NCHW` means that 4D /// tensor `{-1, 3, 480, 640}` will have: /// - 0: `N = -1`: batch dimension is dynamic @@ -33,6 +40,7 @@ namespace ov { /// in layout for appropriate inputs /// /// Refer also to `ov::layout` namespace for various additional helper functions of `ov::Layout` +/// \ingroup ov_layout_cpp_api class OPENVINO_API Layout { public: /// \brief Constructs a dynamic Layout with no layout information. @@ -101,66 +109,79 @@ private: namespace layout { /// \brief Checks if layout has 'batch' dimension +/// \ingroup ov_layout_cpp_api OPENVINO_API bool has_batch(const Layout& layout); /// \brief Returns 'batch' dimension index. /// /// \throws ov::AssertFailure if dimension doesn't exist. /// +/// \ingroup ov_layout_cpp_api OPENVINO_API std::int64_t batch_idx(const Layout& layout); /// \brief Checks if layout has 'channels' dimension /// /// \throws ov::AssertFailure if dimension doesn't exist. /// +/// \ingroup ov_layout_cpp_api OPENVINO_API bool has_channels(const Layout& layout); /// \brief Returns 'channels' dimension index. /// /// \throws ov::AssertFailure if dimension doesn't exist. /// +/// \ingroup ov_layout_cpp_api OPENVINO_API std::int64_t channels_idx(const Layout& layout); /// \brief Checks if layout has 'depth' dimension +/// \ingroup ov_layout_cpp_api OPENVINO_API bool has_depth(const Layout& layout); /// \brief Returns 'depth' dimension index. /// /// \throws ov::AssertFailure if dimension doesn't exist. /// +/// \ingroup ov_layout_cpp_api OPENVINO_API std::int64_t depth_idx(const Layout& layout); /// \brief Checks if layout has 'height' dimension +/// \ingroup ov_layout_cpp_api OPENVINO_API bool has_height(const Layout& layout); /// \brief Returns 'height' dimension index. /// /// \throws ov::AssertFailure if dimension doesn't exist. /// +/// \ingroup ov_layout_cpp_api OPENVINO_API std::int64_t height_idx(const Layout& layout); /// \brief Checks if layout has 'width' dimension +/// \ingroup ov_layout_cpp_api OPENVINO_API bool has_width(const Layout& layout); /// \brief Returns 'width' dimension index. /// /// \throws ov::AssertFailure if dimension doesn't exist. /// +/// \ingroup ov_layout_cpp_api OPENVINO_API std::int64_t width_idx(const Layout& layout); /// \brief Sets Layout of port /// /// \throws ov::Exception if port is not connected with Result or Parameter +/// \ingroup ov_layout_cpp_api OPENVINO_API void set_layout(ov::Output output, const ov::Layout& layout); /// \brief Gets Layout of port /// /// \return layout from port and empty layout in other case +/// \ingroup ov_layout_cpp_api OPENVINO_API ov::Layout get_layout(const ov::Output& output); /// \brief Gets Layout of port /// /// \return layout from port and empty layout in other case +/// \ingroup ov_layout_cpp_api OPENVINO_API ov::Layout get_layout(const ov::Output& output); } // namespace layout diff --git a/src/core/include/openvino/core/node.hpp b/src/core/include/openvino/core/node.hpp index 9472b9d718a..35c4584cfee 100644 --- a/src/core/include/openvino/core/node.hpp +++ b/src/core/include/openvino/core/node.hpp @@ -110,9 +110,12 @@ std::string node_validation_failure_loc_string(const Node* node); class NodeAccessor; -/// Nodes are the backbone of the graph of Value dataflow. Every node has -/// zero or more nodes as arguments and one value, which is either a tensor -/// or a (possibly empty) tuple of values. +/** + * @brief Nodes are the backbone of the graph of Value dataflow. Every node has + * zero or more nodes as arguments and one value, which is either a tensor + * or a (possibly empty) tuple of values. + * @ingroup ov_model_cpp_api + */ class OPENVINO_API Node : public std::enable_shared_from_this { // For access to m_outputs. friend class descriptor::Input; diff --git a/src/core/include/openvino/core/node_input.hpp b/src/core/include/openvino/core/node_input.hpp index a2e30f28487..7db4ba8d395 100644 --- a/src/core/include/openvino/core/node_input.hpp +++ b/src/core/include/openvino/core/node_input.hpp @@ -24,6 +24,7 @@ template class Input {}; /// \brief A handle for one of a node's inputs. +/// \ingroup ov_model_cpp_api template <> class OPENVINO_API Input { public: @@ -75,6 +76,7 @@ private: }; /// \brief A handle for one of a node's inputs. +/// \ingroup ov_model_cpp_api template <> class OPENVINO_API Input { public: diff --git a/src/core/include/openvino/core/node_output.hpp b/src/core/include/openvino/core/node_output.hpp index 27cc2a555df..e2a7734087c 100644 --- a/src/core/include/openvino/core/node_output.hpp +++ b/src/core/include/openvino/core/node_output.hpp @@ -25,6 +25,7 @@ template class Output {}; /// \brief A handle for one of a node's outputs. +/// \ingroup ov_model_cpp_api template <> class OPENVINO_API Output { public: @@ -108,6 +109,8 @@ private: size_t m_index{0}; }; +/// \brief A handle for one of a node's outputs. +/// \ingroup ov_model_cpp_api template <> class OPENVINO_API Output { public: diff --git a/src/core/include/openvino/core/partial_shape.hpp b/src/core/include/openvino/core/partial_shape.hpp index abb4bcc60d7..e1046f95be0 100644 --- a/src/core/include/openvino/core/partial_shape.hpp +++ b/src/core/include/openvino/core/partial_shape.hpp @@ -27,6 +27,7 @@ struct AutoBroadcastSpec; /// (Informal notation examples: `{1,2,?,4}`, `{?,?,?}`) /// \li Static rank, and static dimensions on all axes. /// (Informal notation examples: `{1,2,3,4}`, `{6}`, `{}`) +/// \ingroup ov_model_cpp_api class OPENVINO_API PartialShape { using Dimensions = std::vector; diff --git a/src/core/include/openvino/core/preprocess/pre_post_process.hpp b/src/core/include/openvino/core/preprocess/pre_post_process.hpp index 09a401511f9..a1e0bd166b2 100644 --- a/src/core/include/openvino/core/preprocess/pre_post_process.hpp +++ b/src/core/include/openvino/core/preprocess/pre_post_process.hpp @@ -22,6 +22,7 @@ namespace preprocess { /// For advanced preprocessing scenarios, like combining several functions with multiple inputs/outputs into one, /// client's code can use transformation passes over ov::Model /// +/// \ingroup ov_model_cpp_api class OPENVINO_API PrePostProcessor final { class PrePostProcessorImpl; std::unique_ptr m_impl; diff --git a/src/core/include/openvino/core/shape.hpp b/src/core/include/openvino/core/shape.hpp index a2373140bdc..24f6b41ee8e 100644 --- a/src/core/include/openvino/core/shape.hpp +++ b/src/core/include/openvino/core/shape.hpp @@ -14,7 +14,10 @@ #include "openvino/core/strides.hpp" namespace ov { -/// \brief Shape for a tensor. +/** + * @brief Shape for a tensor. + * @ingroup ov_model_cpp_api + */ class Shape : public std::vector { public: OPENVINO_API Shape(); @@ -36,7 +39,10 @@ public: OPENVINO_API Shape& operator=(Shape&& v) noexcept; }; -/// Number of elements in spanned by a shape +/** + * @brief Number of elements in spanned by a shape + * @ingroup ov_model_cpp_api + */ template size_t shape_size(const SHAPE_TYPE& shape) { size_t size = 1; @@ -46,8 +52,11 @@ size_t shape_size(const SHAPE_TYPE& shape) { return size; } -/// Number of elements in a subset of dimensions of a shape. -/// Returns a product of dimensions in a range [start_dim;end_dim) +/** + * Number of elements in a subset of dimensions of a shape. + * Returns a product of dimensions in a range [start_dim;end_dim) + * @ingroup ov_model_cpp_api + */ template size_t shape_size(ForwardIt start_dim, const ForwardIt end_dim) { static_assert(std::is_arithmetic::value_type>::value, diff --git a/src/core/include/openvino/core/type.hpp b/src/core/include/openvino/core/type.hpp index 6c6f2119d98..c405e29e71e 100644 --- a/src/core/include/openvino/core/type.hpp +++ b/src/core/include/openvino/core/type.hpp @@ -18,13 +18,16 @@ namespace ov { -/// Supports three functions, ov::is_type, ov::as_type, and ov::as_type_ptr for type-safe -/// dynamic conversions via static_cast/static_ptr_cast without using C++ RTTI. -/// Type must have a static type_info member and a virtual get_type_info() member that -/// returns a reference to its type_info member. - -/// Type information for a type system without inheritance; instances have exactly one type not -/// related to any other type. +/** + * @brief Type information for a type system without inheritance; instances have exactly one type not + * related to any other type. + * + * Supports three functions, ov::is_type, ov::as_type, and ov::as_type_ptr for type-safe + * dynamic conversions via static_cast/static_ptr_cast without using C++ RTTI. + * Type must have a static type_info member and a virtual get_type_info() member that + * returns a reference to its type_info member. + * @ingroup ov_model_cpp_api + */ struct OPENVINO_API DiscreteTypeInfo { const char* name; uint64_t version; diff --git a/src/core/include/openvino/core/type/element_type.hpp b/src/core/include/openvino/core/type/element_type.hpp index 9de272a7300..5679e13e52a 100644 --- a/src/core/include/openvino/core/type/element_type.hpp +++ b/src/core/include/openvino/core/type/element_type.hpp @@ -22,29 +22,40 @@ #include "openvino/core/type/bfloat16.hpp" #include "openvino/core/type/float16.hpp" +/** + * @defgroup ov_element_cpp_api Element types + * @ingroup ov_model_cpp_api + * OpenVINO Element API to work with OpenVINO element types + * + */ + namespace ov { namespace element { +/// \brief Enum to define possible element types +/// \ingroup ov_element_cpp_api enum class Type_t { - undefined, - dynamic, - boolean, - bf16, - f16, - f32, - f64, - i4, - i8, - i16, - i32, - i64, - u1, - u4, - u8, - u16, - u32, - u64 + undefined, //!< Undefined element type + dynamic, //!< Dynamic element type + boolean, //!< boolean element type + bf16, //!< bf16 element type + f16, //!< f16 element type + f32, //!< f32 element type + f64, //!< f64 element type + i4, //!< i4 element type + i8, //!< i8 element type + i16, //!< i16 element type + i32, //!< i32 element type + i64, //!< i64 element type + u1, //!< binary element type + u4, //!< u4 element type + u8, //!< u8 element type + u16, //!< u16 element type + u32, //!< u32 element type + u64 //!< u64 element type }; +/// \brief Base class to define element type +/// \ingroup ov_element_cpp_api class OPENVINO_API Type { public: Type() = default; @@ -110,23 +121,59 @@ private: using TypeVector = std::vector; +/// \brief undefined element type +/// \ingroup ov_element_cpp_api constexpr Type undefined(Type_t::undefined); +/// \brief dynamic element type +/// \ingroup ov_element_cpp_api constexpr Type dynamic(Type_t::dynamic); +/// \brief boolean element type +/// \ingroup ov_element_cpp_api constexpr Type boolean(Type_t::boolean); +/// \brief bf16 element type +/// \ingroup ov_element_cpp_api constexpr Type bf16(Type_t::bf16); +/// \brief f16 element type +/// \ingroup ov_element_cpp_api constexpr Type f16(Type_t::f16); +/// \brief f32 element type +/// \ingroup ov_element_cpp_api constexpr Type f32(Type_t::f32); +/// \brief f64 element type +/// \ingroup ov_element_cpp_api constexpr Type f64(Type_t::f64); +/// \brief i4 element type +/// \ingroup ov_element_cpp_api constexpr Type i4(Type_t::i4); +/// \brief i8 element type +/// \ingroup ov_element_cpp_api constexpr Type i8(Type_t::i8); +/// \brief i16 element type +/// \ingroup ov_element_cpp_api constexpr Type i16(Type_t::i16); +/// \brief i32 element type +/// \ingroup ov_element_cpp_api constexpr Type i32(Type_t::i32); +/// \brief i64 element type +/// \ingroup ov_element_cpp_api constexpr Type i64(Type_t::i64); +/// \brief binary element type +/// \ingroup ov_element_cpp_api constexpr Type u1(Type_t::u1); +/// \brief u4 element type +/// \ingroup ov_element_cpp_api constexpr Type u4(Type_t::u4); +/// \brief u8 element type +/// \ingroup ov_element_cpp_api constexpr Type u8(Type_t::u8); +/// \brief u16 element type +/// \ingroup ov_element_cpp_api constexpr Type u16(Type_t::u16); +/// \brief u32 element type +/// \ingroup ov_element_cpp_api constexpr Type u32(Type_t::u32); +/// \brief u64 element type +/// \ingroup ov_element_cpp_api constexpr Type u64(Type_t::u64); template diff --git a/src/core/include/openvino/op/abs.hpp b/src/core/include/openvino/op/abs.hpp index ac96d9f3b8b..64bc37e5f57 100644 --- a/src/core/include/openvino/op/abs.hpp +++ b/src/core/include/openvino/op/abs.hpp @@ -13,6 +13,7 @@ namespace op { namespace v0 { /// \brief Elementwise absolute value operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Abs : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Abs", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/acos.hpp b/src/core/include/openvino/op/acos.hpp index 210830013a3..418fac705f3 100644 --- a/src/core/include/openvino/op/acos.hpp +++ b/src/core/include/openvino/op/acos.hpp @@ -13,6 +13,7 @@ namespace op { namespace v0 { /// \brief Elementwise inverse cosine (arccos) operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Acos : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Acos", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/acosh.hpp b/src/core/include/openvino/op/acosh.hpp index 13454bf7dd8..1f91d38ca7b 100644 --- a/src/core/include/openvino/op/acosh.hpp +++ b/src/core/include/openvino/op/acosh.hpp @@ -13,6 +13,7 @@ namespace op { namespace v3 { /// \brief Elementwise inverse hyperbolic cos operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Acosh : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Acosh", "opset4", util::UnaryElementwiseArithmetic, 3); diff --git a/src/core/include/openvino/op/adaptive_avg_pool.hpp b/src/core/include/openvino/op/adaptive_avg_pool.hpp index 9a20b524c59..95146656908 100644 --- a/src/core/include/openvino/op/adaptive_avg_pool.hpp +++ b/src/core/include/openvino/op/adaptive_avg_pool.hpp @@ -12,6 +12,7 @@ namespace op { namespace v8 { /// \brief Adaptive average pooling operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API AdaptiveAvgPool : public Op { public: OPENVINO_OP("AdaptiveAvgPool", "opset8"); diff --git a/src/core/include/openvino/op/adaptive_max_pool.hpp b/src/core/include/openvino/op/adaptive_max_pool.hpp index 44eb38c33ac..37828627fd9 100644 --- a/src/core/include/openvino/op/adaptive_max_pool.hpp +++ b/src/core/include/openvino/op/adaptive_max_pool.hpp @@ -12,6 +12,7 @@ namespace op { namespace v8 { /// \brief Adaptive max pooling operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API AdaptiveMaxPool : public Op { public: OPENVINO_OP("AdaptiveMaxPool", "opset8"); diff --git a/src/core/include/openvino/op/add.hpp b/src/core/include/openvino/op/add.hpp index 0eaafaf52b0..526d089a1e0 100644 --- a/src/core/include/openvino/op/add.hpp +++ b/src/core/include/openvino/op/add.hpp @@ -13,6 +13,7 @@ namespace op { namespace v1 { /// \brief Elementwise addition operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Add : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Add", "opset1", util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/asin.hpp b/src/core/include/openvino/op/asin.hpp index 637b0123993..5cb148805b7 100644 --- a/src/core/include/openvino/op/asin.hpp +++ b/src/core/include/openvino/op/asin.hpp @@ -13,6 +13,7 @@ namespace op { namespace v0 { /// \brief Elementwise inverse sine (arcsin) operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Asin : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Asin", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/assign.hpp b/src/core/include/openvino/op/assign.hpp index fad9820cd85..57dff00f1db 100644 --- a/src/core/include/openvino/op/assign.hpp +++ b/src/core/include/openvino/op/assign.hpp @@ -11,6 +11,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Assign operation sets an input value to the variable with `variable_id` +/// \ingroup ov_ops_cpp_api class OPENVINO_API Assign : public util::AssignBase { public: OPENVINO_OP("Assign", "opset3", op::Sink, 3); @@ -41,6 +42,7 @@ private: namespace v6 { /// \brief Assign operation sets an input value to the variable with `variable_id` +/// \ingroup ov_ops_cpp_api class OPENVINO_API Assign : public util::AssignBase { public: OPENVINO_OP("Assign", "opset6", op::Sink, 6); diff --git a/src/core/include/openvino/op/atan.hpp b/src/core/include/openvino/op/atan.hpp index 135d2cb7b2b..9f61ffd7c3f 100644 --- a/src/core/include/openvino/op/atan.hpp +++ b/src/core/include/openvino/op/atan.hpp @@ -13,6 +13,7 @@ namespace op { namespace v0 { /// \brief Elementwise inverse tangent (arctan) operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Atan : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Atan", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/atanh.hpp b/src/core/include/openvino/op/atanh.hpp index 6c571c2661d..5b9aa04fe28 100644 --- a/src/core/include/openvino/op/atanh.hpp +++ b/src/core/include/openvino/op/atanh.hpp @@ -13,6 +13,7 @@ namespace op { namespace v3 { /// \brief Elementwise inverse hyperbolic tangent operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Atanh : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Atanh", "opset4", util::UnaryElementwiseArithmetic, 3); diff --git a/src/core/include/openvino/op/batch_norm.hpp b/src/core/include/openvino/op/batch_norm.hpp index c29c4020215..d6d1204e376 100644 --- a/src/core/include/openvino/op/batch_norm.hpp +++ b/src/core/include/openvino/op/batch_norm.hpp @@ -11,6 +11,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief BatchNormInference operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API BatchNormInference : public Op { public: OPENVINO_OP("BatchNormInference", "opset1"); @@ -52,6 +55,9 @@ private: }; } // namespace v0 namespace v5 { +/// \brief BatchNormInference operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API BatchNormInference : public Op { public: OPENVINO_OP("BatchNormInference", "opset5", op::Op, 5); diff --git a/src/core/include/openvino/op/batch_to_space.hpp b/src/core/include/openvino/op/batch_to_space.hpp index 291ec4eb881..8a25f81f2fd 100644 --- a/src/core/include/openvino/op/batch_to_space.hpp +++ b/src/core/include/openvino/op/batch_to_space.hpp @@ -20,6 +20,7 @@ namespace v1 { /// D_2 * block_shape[2] - crops_begin[2] - crops_end[2], ..., /// D_{N - 1} * block_shape[N - 1] - crops_begin[N - 1] - crops_end[N - 1]` /// of the same type as `data` input. +/// \ingroup ov_ops_cpp_api class OPENVINO_API BatchToSpace : public Op { public: OPENVINO_OP("BatchToSpace", "opset2", op::Op, 1); diff --git a/src/core/include/openvino/op/binary_convolution.hpp b/src/core/include/openvino/op/binary_convolution.hpp index 6f09f6aaf4b..c83cb909695 100644 --- a/src/core/include/openvino/op/binary_convolution.hpp +++ b/src/core/include/openvino/op/binary_convolution.hpp @@ -11,6 +11,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief BinaryConvolution operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API BinaryConvolution : public Op { public: OPENVINO_OP("BinaryConvolution", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/broadcast.hpp b/src/core/include/openvino/op/broadcast.hpp index 57759949d1d..9279745a7f7 100644 --- a/src/core/include/openvino/op/broadcast.hpp +++ b/src/core/include/openvino/op/broadcast.hpp @@ -14,6 +14,7 @@ namespace op { namespace v3 { /// \brief Operation which "adds" axes to an input tensor, replicating elements from the /// input as needed along the new axes. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Broadcast : public util::BroadcastBase { public: OPENVINO_OP("Broadcast", "opset3", op::util::BroadcastBase, 3); @@ -78,6 +79,7 @@ private: namespace v1 { /// \brief Operation which "adds" axes to an input tensor, replicating elements from the /// input as needed along the new axes. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Broadcast : public util::BroadcastBase { public: OPENVINO_OP("Broadcast", "opset1", op::util::BroadcastBase, 1); diff --git a/src/core/include/openvino/op/bucketize.hpp b/src/core/include/openvino/op/bucketize.hpp index 8541e751600..63041c4cda7 100644 --- a/src/core/include/openvino/op/bucketize.hpp +++ b/src/core/include/openvino/op/bucketize.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Operation that bucketizes the input based on boundaries +/// \ingroup ov_ops_cpp_api class OPENVINO_API Bucketize : public Op { public: OPENVINO_OP("Bucketize", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/ceiling.hpp b/src/core/include/openvino/op/ceiling.hpp index d12f7d9a8c6..6429b646467 100644 --- a/src/core/include/openvino/op/ceiling.hpp +++ b/src/core/include/openvino/op/ceiling.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise ceiling operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Ceiling : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Ceiling", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/clamp.hpp b/src/core/include/openvino/op/clamp.hpp index 3c68ad6d073..e08341f1140 100644 --- a/src/core/include/openvino/op/clamp.hpp +++ b/src/core/include/openvino/op/clamp.hpp @@ -14,6 +14,7 @@ namespace v0 { /// All input values that are outside of the range are set to 'min' or 'max' /// depending on which side of the range they are. The values that fall into /// this range remain unchanged. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Clamp : public Op { public: OPENVINO_OP("Clamp", "opset1"); diff --git a/src/core/include/openvino/op/concat.hpp b/src/core/include/openvino/op/concat.hpp index 18d29b5ee06..0ee294e5861 100644 --- a/src/core/include/openvino/op/concat.hpp +++ b/src/core/include/openvino/op/concat.hpp @@ -12,6 +12,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Concatenation operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Concat : public Op { public: OPENVINO_OP("Concat", "opset1"); diff --git a/src/core/include/openvino/op/constant.hpp b/src/core/include/openvino/op/constant.hpp index e65a22cf11f..6058eeb7dca 100644 --- a/src/core/include/openvino/op/constant.hpp +++ b/src/core/include/openvino/op/constant.hpp @@ -19,6 +19,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Class for constants. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Constant : public Op { public: OPENVINO_OP("Constant", "opset1"); diff --git a/src/core/include/openvino/op/convert.hpp b/src/core/include/openvino/op/convert.hpp index a44d7bbbc64..d2d907d49a4 100644 --- a/src/core/include/openvino/op/convert.hpp +++ b/src/core/include/openvino/op/convert.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise type conversion operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Convert : public Op { public: OPENVINO_OP("Convert", "opset1"); diff --git a/src/core/include/openvino/op/convert_like.hpp b/src/core/include/openvino/op/convert_like.hpp index 8ec601b84f2..ed63a2f5269 100644 --- a/src/core/include/openvino/op/convert_like.hpp +++ b/src/core/include/openvino/op/convert_like.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise type conversion operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ConvertLike : public Op { public: OPENVINO_OP("ConvertLike", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/convolution.hpp b/src/core/include/openvino/op/convolution.hpp index c6005142855..e3b83f47d4d 100644 --- a/src/core/include/openvino/op/convolution.hpp +++ b/src/core/include/openvino/op/convolution.hpp @@ -13,6 +13,7 @@ namespace op { namespace v1 { /// \brief Batched convolution operation, with optional window dilation and stride. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Convolution : public Op { public: OPENVINO_OP("Convolution", "opset1", op::Op, 1); @@ -127,6 +128,7 @@ private: }; /// \brief Data batch backprop for batched convolution operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ConvolutionBackpropData : public Op { public: OPENVINO_OP("ConvolutionBackpropData", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/cos.hpp b/src/core/include/openvino/op/cos.hpp index 850db68858b..b1d60596659 100644 --- a/src/core/include/openvino/op/cos.hpp +++ b/src/core/include/openvino/op/cos.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise cosine operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Cos : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Cos", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/cosh.hpp b/src/core/include/openvino/op/cosh.hpp index bb7c7fd9dd6..7f44084d2b6 100644 --- a/src/core/include/openvino/op/cosh.hpp +++ b/src/core/include/openvino/op/cosh.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise hyperbolic cosine (cosh) operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Cosh : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Cosh", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/ctc_greedy_decoder.hpp b/src/core/include/openvino/op/ctc_greedy_decoder.hpp index 2903f273bf1..c41e3de2dbf 100644 --- a/src/core/include/openvino/op/ctc_greedy_decoder.hpp +++ b/src/core/include/openvino/op/ctc_greedy_decoder.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief CTCGreedyDecoder operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API CTCGreedyDecoder : public Op { public: OPENVINO_OP("CTCGreedyDecoder", "opset1"); diff --git a/src/core/include/openvino/op/ctc_greedy_decoder_seq_len.hpp b/src/core/include/openvino/op/ctc_greedy_decoder_seq_len.hpp index a94243c58ec..c2ab315b4cd 100644 --- a/src/core/include/openvino/op/ctc_greedy_decoder_seq_len.hpp +++ b/src/core/include/openvino/op/ctc_greedy_decoder_seq_len.hpp @@ -11,6 +11,7 @@ namespace op { namespace v6 { /// \brief Operator performing CTCGreedyDecoder /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API CTCGreedyDecoderSeqLen : public Op { public: OPENVINO_OP("CTCGreedyDecoderSeqLen", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/ctc_loss.hpp b/src/core/include/openvino/op/ctc_loss.hpp index 2a118f7f92f..6f81a93e8ad 100644 --- a/src/core/include/openvino/op/ctc_loss.hpp +++ b/src/core/include/openvino/op/ctc_loss.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v4 { +/// \brief CTCLoss operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API CTCLoss : public Op { public: OPENVINO_OP("CTCLoss", "opset4", op::Op, 4); diff --git a/src/core/include/openvino/op/cum_sum.hpp b/src/core/include/openvino/op/cum_sum.hpp index d544efd6d40..976294e91f9 100644 --- a/src/core/include/openvino/op/cum_sum.hpp +++ b/src/core/include/openvino/op/cum_sum.hpp @@ -14,6 +14,7 @@ namespace v0 { /// /// Compute the cumulative sum of the input tensor along the axis specified. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API CumSum : public Op { public: OPENVINO_OP("CumSum", "opset3"); diff --git a/src/core/include/openvino/op/deformable_convolution.hpp b/src/core/include/openvino/op/deformable_convolution.hpp index 6e24482ac2a..729fcc12cad 100644 --- a/src/core/include/openvino/op/deformable_convolution.hpp +++ b/src/core/include/openvino/op/deformable_convolution.hpp @@ -13,6 +13,7 @@ namespace ov { namespace op { namespace v1 { /// \brief DeformableConvolution operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API DeformableConvolution : public op::util::DeformableConvolutionBase { public: OPENVINO_OP("DeformableConvolution", "opset1", op::util::DeformableConvolutionBase, 1); @@ -57,6 +58,9 @@ public: } // namespace v1 namespace v8 { +/// \brief DeformableConvolution operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API DeformableConvolution : public op::util::DeformableConvolutionBase { public: OPENVINO_OP("DeformableConvolution", "opset8", op::util::DeformableConvolutionBase); diff --git a/src/core/include/openvino/op/deformable_psroi_pooling.hpp b/src/core/include/openvino/op/deformable_psroi_pooling.hpp index cb456c1d50d..37569d3b0b6 100644 --- a/src/core/include/openvino/op/deformable_psroi_pooling.hpp +++ b/src/core/include/openvino/op/deformable_psroi_pooling.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief DeformablePSROIPooling operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API DeformablePSROIPooling : public Op { public: OPENVINO_OP("DeformablePSROIPooling", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/depth_to_space.hpp b/src/core/include/openvino/op/depth_to_space.hpp index f3e18f6a9a8..f165fbff60f 100644 --- a/src/core/include/openvino/op/depth_to_space.hpp +++ b/src/core/include/openvino/op/depth_to_space.hpp @@ -18,6 +18,7 @@ namespace v0 { /// /// Output node produces a tensor with shape: /// [N, C/(blocksize * blocksize), H * blocksize, W * blocksize] +/// \ingroup ov_ops_cpp_api class OPENVINO_API DepthToSpace : public Op { public: OPENVINO_OP("DepthToSpace", "opset1"); diff --git a/src/core/include/openvino/op/dft.hpp b/src/core/include/openvino/op/dft.hpp index 0a8b48af56a..3c270833913 100644 --- a/src/core/include/openvino/op/dft.hpp +++ b/src/core/include/openvino/op/dft.hpp @@ -26,6 +26,7 @@ namespace ov { namespace op { namespace v7 { /// \brief An operation DFT that computes the discrete Fourier transformation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API DFT : public util::FFTBase { public: OPENVINO_OP("DFT", "opset7", util::FFTBase, 7); diff --git a/src/core/include/openvino/op/divide.hpp b/src/core/include/openvino/op/divide.hpp index fccc4818108..f524b83e799 100644 --- a/src/core/include/openvino/op/divide.hpp +++ b/src/core/include/openvino/op/divide.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise division operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Divide : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Divide", "opset1", util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/einsum.hpp b/src/core/include/openvino/op/einsum.hpp index 64b66436005..e028abea431 100644 --- a/src/core/include/openvino/op/einsum.hpp +++ b/src/core/include/openvino/op/einsum.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v7 { /// \brief Einsum operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Einsum : public Op { public: OPENVINO_OP("Einsum", "opset7", op::Op, 7); diff --git a/src/core/include/openvino/op/elu.hpp b/src/core/include/openvino/op/elu.hpp index aab5c84f311..6ef2dce872b 100644 --- a/src/core/include/openvino/op/elu.hpp +++ b/src/core/include/openvino/op/elu.hpp @@ -13,6 +13,7 @@ namespace v0 { /// x < 0 => f(x) = alpha * (exp(x) - 1.) /// x >= 0 => f(x) = x /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Elu : public Op { public: OPENVINO_OP("Elu", "opset1"); diff --git a/src/core/include/openvino/op/embedding_segments_sum.hpp b/src/core/include/openvino/op/embedding_segments_sum.hpp index 755aaf1f986..d021fb9cf55 100644 --- a/src/core/include/openvino/op/embedding_segments_sum.hpp +++ b/src/core/include/openvino/op/embedding_segments_sum.hpp @@ -11,6 +11,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Returns embeddings for given indices +/// \ingroup ov_ops_cpp_api class OPENVINO_API EmbeddingSegmentsSum : public Op { public: OPENVINO_OP("EmbeddingSegmentsSum", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/embeddingbag_offsets_sum.hpp b/src/core/include/openvino/op/embeddingbag_offsets_sum.hpp index bf2d7824a7b..6cb37b0157a 100644 --- a/src/core/include/openvino/op/embeddingbag_offsets_sum.hpp +++ b/src/core/include/openvino/op/embeddingbag_offsets_sum.hpp @@ -12,6 +12,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Returns embeddings for given indices +/// \ingroup ov_ops_cpp_api class OPENVINO_API EmbeddingBagOffsetsSum : public util::EmbeddingBagOffsetsBase { public: OPENVINO_OP("EmbeddingBagOffsetsSum", "opset3", util::EmbeddingBagOffsetsBase, 3); diff --git a/src/core/include/openvino/op/embeddingbag_packedsum.hpp b/src/core/include/openvino/op/embeddingbag_packedsum.hpp index bf264ef81f5..b9f4654a15b 100644 --- a/src/core/include/openvino/op/embeddingbag_packedsum.hpp +++ b/src/core/include/openvino/op/embeddingbag_packedsum.hpp @@ -12,6 +12,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Returns embeddings for given indices +/// \ingroup ov_ops_cpp_api class OPENVINO_API EmbeddingBagPackedSum : public util::EmbeddingBagPackedBase { public: OPENVINO_OP("EmbeddingBagPackedSum", "opset3", util::EmbeddingBagPackedBase, 3); diff --git a/src/core/include/openvino/op/equal.hpp b/src/core/include/openvino/op/equal.hpp index 37535072624..fa001480aa5 100644 --- a/src/core/include/openvino/op/equal.hpp +++ b/src/core/include/openvino/op/equal.hpp @@ -25,6 +25,7 @@ namespace v1 { /// | Type | Description | /// | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | /// | \f$\texttt{bool}[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = 1\text{ if }\texttt{arg0}[i_1,\dots,i_n] = \texttt{arg1}[i_1,\dots,i_n]\text{, else } 0\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API Equal : public util::BinaryElementwiseComparison { public: diff --git a/src/core/include/openvino/op/erf.hpp b/src/core/include/openvino/op/erf.hpp index 218d3e9a6d8..637566c7f8e 100644 --- a/src/core/include/openvino/op/erf.hpp +++ b/src/core/include/openvino/op/erf.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise erf operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Erf : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Erf", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/exp.hpp b/src/core/include/openvino/op/exp.hpp index f0cb2b806ca..312909f12d5 100644 --- a/src/core/include/openvino/op/exp.hpp +++ b/src/core/include/openvino/op/exp.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise natural exponential (exp) operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Exp : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Exp", "opset1", UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/experimental_detectron_detection_output.hpp b/src/core/include/openvino/op/experimental_detectron_detection_output.hpp index 710ad1633ec..e940db9c3ba 100644 --- a/src/core/include/openvino/op/experimental_detectron_detection_output.hpp +++ b/src/core/include/openvino/op/experimental_detectron_detection_output.hpp @@ -17,6 +17,7 @@ namespace v6 { /// \brief An operation ExperimentalDetectronDetectionOutput performs /// non-maximum suppression to generate the detection output using /// information on location and score predictions. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ExperimentalDetectronDetectionOutput : public Op { public: OPENVINO_OP("ExperimentalDetectronDetectionOutput", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/experimental_detectron_generate_proposals.hpp b/src/core/include/openvino/op/experimental_detectron_generate_proposals.hpp index e331f9ae271..e547d1145df 100644 --- a/src/core/include/openvino/op/experimental_detectron_generate_proposals.hpp +++ b/src/core/include/openvino/op/experimental_detectron_generate_proposals.hpp @@ -16,6 +16,7 @@ namespace op { namespace v6 { /// \brief An operation ExperimentalDetectronGenerateProposalsSingleImage /// computes ROIs and their scores based on input data. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ExperimentalDetectronGenerateProposalsSingleImage : public Op { public: OPENVINO_OP("ExperimentalDetectronGenerateProposalsSingleImage", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/experimental_detectron_prior_grid_generator.hpp b/src/core/include/openvino/op/experimental_detectron_prior_grid_generator.hpp index f017fc41182..06d5c8dd5f5 100644 --- a/src/core/include/openvino/op/experimental_detectron_prior_grid_generator.hpp +++ b/src/core/include/openvino/op/experimental_detectron_prior_grid_generator.hpp @@ -16,6 +16,7 @@ namespace op { namespace v6 { /// \brief An operation ExperimentalDetectronPriorGridGenerator generates prior /// grids of specified sizes. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ExperimentalDetectronPriorGridGenerator : public Op { public: OPENVINO_OP("ExperimentalDetectronPriorGridGenerator", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/experimental_detectron_roi_feature.hpp b/src/core/include/openvino/op/experimental_detectron_roi_feature.hpp index c7301075411..7c654e4d9b9 100644 --- a/src/core/include/openvino/op/experimental_detectron_roi_feature.hpp +++ b/src/core/include/openvino/op/experimental_detectron_roi_feature.hpp @@ -17,6 +17,7 @@ namespace op { namespace v6 { /// \brief An operation ExperimentalDetectronROIFeatureExtractor /// is the ROIAlign operation applied over a feature pyramid. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ExperimentalDetectronROIFeatureExtractor : public Op { public: OPENVINO_OP("ExperimentalDetectronROIFeatureExtractor", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/experimental_detectron_topkrois.hpp b/src/core/include/openvino/op/experimental_detectron_topkrois.hpp index 4c2c1085258..741eab4ee41 100644 --- a/src/core/include/openvino/op/experimental_detectron_topkrois.hpp +++ b/src/core/include/openvino/op/experimental_detectron_topkrois.hpp @@ -16,6 +16,7 @@ namespace op { namespace v6 { /// \brief An operation ExperimentalDetectronTopKROIs, according to the repository /// is TopK operation applied to probabilities of input ROIs. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ExperimentalDetectronTopKROIs : public Op { public: OPENVINO_OP("ExperimentalDetectronTopKROIs", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/extractimagepatches.hpp b/src/core/include/openvino/op/extractimagepatches.hpp index 0afc9934927..537c09e923e 100644 --- a/src/core/include/openvino/op/extractimagepatches.hpp +++ b/src/core/include/openvino/op/extractimagepatches.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v3 { +/// \brief ExtractImagePatches operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ExtractImagePatches : public Op { public: OPENVINO_OP("ExtractImagePatches", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/fake_quantize.hpp b/src/core/include/openvino/op/fake_quantize.hpp index a35076c1770..cfd9581898f 100644 --- a/src/core/include/openvino/op/fake_quantize.hpp +++ b/src/core/include/openvino/op/fake_quantize.hpp @@ -23,6 +23,7 @@ namespace v0 { /// (levels-1) * (output_high - output_low) + output_low /// /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API FakeQuantize : public Op { public: OPENVINO_OP("FakeQuantize", "opset1"); diff --git a/src/core/include/openvino/op/floor.hpp b/src/core/include/openvino/op/floor.hpp index 69fad8adf65..3e42b9ff6b3 100644 --- a/src/core/include/openvino/op/floor.hpp +++ b/src/core/include/openvino/op/floor.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise floor operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Floor : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Floor", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/floor_mod.hpp b/src/core/include/openvino/op/floor_mod.hpp index 745d97598f7..44350986896 100644 --- a/src/core/include/openvino/op/floor_mod.hpp +++ b/src/core/include/openvino/op/floor_mod.hpp @@ -11,6 +11,7 @@ namespace op { namespace v1 { /// \brief Elementwise FloorMod operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API FloorMod : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("FloorMod", "opset1", op::util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/gather.hpp b/src/core/include/openvino/op/gather.hpp index f1a6206ed74..376e1112cb7 100644 --- a/src/core/include/openvino/op/gather.hpp +++ b/src/core/include/openvino/op/gather.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Gather slices from axis of data according to indices +/// \ingroup ov_ops_cpp_api class OPENVINO_API Gather : public op::util::GatherBase { public: OPENVINO_OP("Gather", "opset1", op::util::GatherBase, 1); @@ -30,6 +31,7 @@ public: namespace v7 { /// \brief Gather slices from axis of data according to indices +/// \ingroup ov_ops_cpp_api class OPENVINO_API Gather : public op::util::GatherBase { public: OPENVINO_OP("Gather", "opset7", op::util::GatherBase, 7); @@ -57,6 +59,7 @@ public: namespace v8 { /// \brief Gather slices from axis of data according to indices. Negative indices /// are supported and indicate reverse indexing from the end +/// \ingroup ov_ops_cpp_api class OPENVINO_API Gather : public op::util::GatherBase { public: OPENVINO_OP("Gather", "opset8", op::util::GatherBase); diff --git a/src/core/include/openvino/op/gather_elements.hpp b/src/core/include/openvino/op/gather_elements.hpp index 8df970e44f5..e3ae64b532b 100644 --- a/src/core/include/openvino/op/gather_elements.hpp +++ b/src/core/include/openvino/op/gather_elements.hpp @@ -11,6 +11,7 @@ namespace op { namespace v6 { /// \brief GatherElements operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API GatherElements : public Op { public: OPENVINO_OP("GatherElements", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/gather_nd.hpp b/src/core/include/openvino/op/gather_nd.hpp index f370bd8e362..451ae230699 100644 --- a/src/core/include/openvino/op/gather_nd.hpp +++ b/src/core/include/openvino/op/gather_nd.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v5 { /// \brief GatherND operation +/// \ingroup ov_ops_cpp_api class OPENVINO_API GatherND : public op::util::GatherNDBase { public: OPENVINO_OP("GatherND", "opset5", op::util::GatherNDBase, 5); @@ -32,6 +33,7 @@ public: namespace v8 { /// \brief GatherND operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API GatherND : public op::util::GatherNDBase { public: OPENVINO_OP("GatherND", "opset8", op::util::GatherNDBase); diff --git a/src/core/include/openvino/op/gather_tree.hpp b/src/core/include/openvino/op/gather_tree.hpp index cc655600058..39719673bb8 100644 --- a/src/core/include/openvino/op/gather_tree.hpp +++ b/src/core/include/openvino/op/gather_tree.hpp @@ -11,6 +11,7 @@ namespace op { namespace v1 { /// \brief Generates the complete beams from the ids per each step and the parent beam /// ids. +/// \ingroup ov_ops_cpp_api class OPENVINO_API GatherTree : public Op { public: OPENVINO_OP("GatherTree", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/gelu.hpp b/src/core/include/openvino/op/gelu.hpp index bea45c264bd..ada2be3fadc 100644 --- a/src/core/include/openvino/op/gelu.hpp +++ b/src/core/include/openvino/op/gelu.hpp @@ -12,6 +12,7 @@ namespace op { namespace v0 { /// \brief Gaussian Error Linear Unit /// f(x) = 0.5 * x * (1 + erf( x / sqrt(2) ) +/// \ingroup ov_ops_cpp_api class OPENVINO_API Gelu : public Op { public: OPENVINO_OP("Gelu", "opset2", op::Op, 0); @@ -40,6 +41,7 @@ namespace v7 { /// f(x) = 0.5 * x * (1 + erf( x / sqrt(2) ) for "approximation" = "erf" /// f(x) = 0.5 * x * (1 + tanh([sqrt(2 / pi)] * [x + 0.044715^3]) for "approximation" = /// "tanh" +/// \ingroup ov_ops_cpp_api class OPENVINO_API Gelu : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Gelu", "opset7", op::Op, 7); diff --git a/src/core/include/openvino/op/greater.hpp b/src/core/include/openvino/op/greater.hpp index 9e02ff4cfde..f524d4d20b3 100644 --- a/src/core/include/openvino/op/greater.hpp +++ b/src/core/include/openvino/op/greater.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise greater-than operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Greater : public util::BinaryElementwiseComparison { public: OPENVINO_OP("Greater", "opset1", op::util::BinaryElementwiseComparison, 1); diff --git a/src/core/include/openvino/op/greater_eq.hpp b/src/core/include/openvino/op/greater_eq.hpp index abb845415bb..67cb7ab0989 100644 --- a/src/core/include/openvino/op/greater_eq.hpp +++ b/src/core/include/openvino/op/greater_eq.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise greater-than-or-equal operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API GreaterEqual : public util::BinaryElementwiseComparison { public: OPENVINO_OP("GreaterEqual", "opset1", op::util::BinaryElementwiseComparison, 1); diff --git a/src/core/include/openvino/op/gru_cell.hpp b/src/core/include/openvino/op/gru_cell.hpp index d838cb18d47..1e71e046006 100644 --- a/src/core/include/openvino/op/gru_cell.hpp +++ b/src/core/include/openvino/op/gru_cell.hpp @@ -21,6 +21,7 @@ namespace v3 { /// /// \note Note this class represents only single *cell* and not whole GRU *layer*. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API GRUCell : public util::RNNCellBase { public: OPENVINO_OP("GRUCell", "opset3", op::util::RNNCellBase, 3); diff --git a/src/core/include/openvino/op/gru_sequence.hpp b/src/core/include/openvino/op/gru_sequence.hpp index b80fbd1c32b..5211ff46cee 100644 --- a/src/core/include/openvino/op/gru_sequence.hpp +++ b/src/core/include/openvino/op/gru_sequence.hpp @@ -14,6 +14,9 @@ namespace ov { namespace op { namespace v5 { +/// \brief GRUSequence operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API GRUSequence : public util::RNNCellBase { public: OPENVINO_OP("GRUSequence", "opset5", op::Op, 5); diff --git a/src/core/include/openvino/op/hard_sigmoid.hpp b/src/core/include/openvino/op/hard_sigmoid.hpp index 5fb9e5d360d..5608c2773b0 100644 --- a/src/core/include/openvino/op/hard_sigmoid.hpp +++ b/src/core/include/openvino/op/hard_sigmoid.hpp @@ -12,6 +12,7 @@ namespace v0 { /// \brief Parameterized, bounded sigmoid-like, piecewise linear /// function. min(max(alpha*x + beta, 0), 1) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API HardSigmoid : public Op { public: OPENVINO_OP("HardSigmoid", "opset1"); diff --git a/src/core/include/openvino/op/hsigmoid.hpp b/src/core/include/openvino/op/hsigmoid.hpp index e67cb19f31a..ee977433835 100644 --- a/src/core/include/openvino/op/hsigmoid.hpp +++ b/src/core/include/openvino/op/hsigmoid.hpp @@ -14,6 +14,7 @@ namespace v5 { /// f(x) = min(max(x + 3, 0), 6) / 6 or /// f(x) = min(ReLU(x + 3), 6) / 6 /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API HSigmoid : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("HSigmoid", "opset5", op::util::UnaryElementwiseArithmetic, 5); diff --git a/src/core/include/openvino/op/hswish.hpp b/src/core/include/openvino/op/hswish.hpp index fbf1967f4b1..a77e3d136d7 100644 --- a/src/core/include/openvino/op/hswish.hpp +++ b/src/core/include/openvino/op/hswish.hpp @@ -14,6 +14,7 @@ namespace v4 { /// f(x) = x * min(max(x + 3, 0), 6) / 6 or /// f(x) = x * min(ReLU(x + 3), 6) / 6 /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API HSwish : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("HSwish", "opset4", op::util::UnaryElementwiseArithmetic, 4); diff --git a/src/core/include/openvino/op/i420_to_bgr.hpp b/src/core/include/openvino/op/i420_to_bgr.hpp index 874fb994bd2..fc8e1efaad2 100644 --- a/src/core/include/openvino/op/i420_to_bgr.hpp +++ b/src/core/include/openvino/op/i420_to_bgr.hpp @@ -30,6 +30,7 @@ namespace v8 { /// B = 1.164 * (Y - 16) + 2.018 * (U - 128) /// Then R, G, B values are clipped to range (0, 255) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API I420toBGR : public util::ConvertColorI420Base { public: OPENVINO_OP("I420toBGR", "opset8", util::ConvertColorI420Base); diff --git a/src/core/include/openvino/op/i420_to_rgb.hpp b/src/core/include/openvino/op/i420_to_rgb.hpp index d7a5aaa7cb8..32dbc9b00c0 100644 --- a/src/core/include/openvino/op/i420_to_rgb.hpp +++ b/src/core/include/openvino/op/i420_to_rgb.hpp @@ -30,6 +30,7 @@ namespace v8 { /// B = 1.164 * (Y - 16) + 2.018 * (U - 128) /// Then R, G, B values are clipped to range (0, 255) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API I420toRGB : public util::ConvertColorI420Base { public: OPENVINO_OP("I420toRGB", "opset8", util::ConvertColorI420Base); diff --git a/src/core/include/openvino/op/idft.hpp b/src/core/include/openvino/op/idft.hpp index 796c036c028..4d1a04c5155 100644 --- a/src/core/include/openvino/op/idft.hpp +++ b/src/core/include/openvino/op/idft.hpp @@ -14,6 +14,7 @@ namespace ov { namespace op { namespace v7 { /// \brief An operation IDFT that computes the inverse discrete Fourier transformation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API IDFT : public util::FFTBase { public: OPENVINO_OP("IDFT", "opset7", util::FFTBase, 7); diff --git a/src/core/include/openvino/op/if.hpp b/src/core/include/openvino/op/if.hpp index 5384c670920..d39b2095df5 100644 --- a/src/core/include/openvino/op/if.hpp +++ b/src/core/include/openvino/op/if.hpp @@ -14,6 +14,7 @@ namespace ov { namespace op { namespace v8 { /// \brief If operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API If : public util::MultiSubGraphOp { public: OPENVINO_OP("If", "opset8", MultiSubGraphOp); diff --git a/src/core/include/openvino/op/interpolate.hpp b/src/core/include/openvino/op/interpolate.hpp index ef8c0ffce35..6bd2b9cbb6a 100644 --- a/src/core/include/openvino/op/interpolate.hpp +++ b/src/core/include/openvino/op/interpolate.hpp @@ -17,6 +17,7 @@ namespace op { namespace v0 { /// \brief Layer which performs bilinear interpolation +/// \ingroup ov_ops_cpp_api class OPENVINO_API Interpolate : public Op { public: OPENVINO_OP("Interpolate", "opset1"); @@ -77,6 +78,9 @@ private: } // namespace v0 namespace v4 { +/// \brief Interpolate operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Interpolate : public Op { public: OPENVINO_OP("Interpolate", "opset4", op::Op, 4); diff --git a/src/core/include/openvino/op/less.hpp b/src/core/include/openvino/op/less.hpp index a800a5f1494..6e3f48b23cf 100644 --- a/src/core/include/openvino/op/less.hpp +++ b/src/core/include/openvino/op/less.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise less-than operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Less : public util::BinaryElementwiseComparison { public: OPENVINO_OP("Less", "opset1", op::util::BinaryElementwiseComparison, 1); diff --git a/src/core/include/openvino/op/less_eq.hpp b/src/core/include/openvino/op/less_eq.hpp index 445ccdc6dbf..043dba98e71 100644 --- a/src/core/include/openvino/op/less_eq.hpp +++ b/src/core/include/openvino/op/less_eq.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise less-than-or-equal operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API LessEqual : public util::BinaryElementwiseComparison { public: OPENVINO_OP("LessEqual", "opset1", op::util::BinaryElementwiseComparison, 1); diff --git a/src/core/include/openvino/op/log.hpp b/src/core/include/openvino/op/log.hpp index de0a8441ad5..680b480da72 100644 --- a/src/core/include/openvino/op/log.hpp +++ b/src/core/include/openvino/op/log.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise natural log operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Log : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Log", "opset1", op::util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/log_softmax.hpp b/src/core/include/openvino/op/log_softmax.hpp index 30ca400e88f..a8ca66da78f 100644 --- a/src/core/include/openvino/op/log_softmax.hpp +++ b/src/core/include/openvino/op/log_softmax.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v5 { +/// \brief LogSoftmax operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LogSoftmax : public Op { public: OPENVINO_OP("LogSoftmax", "opset5", op::Op, 5); diff --git a/src/core/include/openvino/op/logical_and.hpp b/src/core/include/openvino/op/logical_and.hpp index fb998d74a40..0d20f2f9b0f 100644 --- a/src/core/include/openvino/op/logical_and.hpp +++ b/src/core/include/openvino/op/logical_and.hpp @@ -13,6 +13,7 @@ namespace op { namespace v1 { /// \brief Elementwise logical-and operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LogicalAnd : public util::BinaryElementwiseLogical { public: OPENVINO_OP("LogicalAnd", "opset1", util::BinaryElementwiseLogical, 1); diff --git a/src/core/include/openvino/op/logical_not.hpp b/src/core/include/openvino/op/logical_not.hpp index c81cc7a5162..533cc7fc921 100644 --- a/src/core/include/openvino/op/logical_not.hpp +++ b/src/core/include/openvino/op/logical_not.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise logical negation operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API LogicalNot : public Op { public: OPENVINO_OP("LogicalNot", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/logical_or.hpp b/src/core/include/openvino/op/logical_or.hpp index f9ec6e0e11b..7dd79945433 100644 --- a/src/core/include/openvino/op/logical_or.hpp +++ b/src/core/include/openvino/op/logical_or.hpp @@ -13,6 +13,7 @@ namespace op { namespace v1 { /// \brief Elementwise logical-or operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LogicalOr : public util::BinaryElementwiseLogical { public: OPENVINO_OP("LogicalOr", "opset1", util::BinaryElementwiseLogical, 1); diff --git a/src/core/include/openvino/op/logical_xor.hpp b/src/core/include/openvino/op/logical_xor.hpp index b37cb6515db..1b35dc0c24c 100644 --- a/src/core/include/openvino/op/logical_xor.hpp +++ b/src/core/include/openvino/op/logical_xor.hpp @@ -13,6 +13,7 @@ namespace op { namespace v1 { /// \brief Elementwise logical-xor operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LogicalXor : public util::BinaryElementwiseLogical { public: OPENVINO_OP("LogicalXor", "opset2", util::BinaryElementwiseLogical, 1); diff --git a/src/core/include/openvino/op/loop.hpp b/src/core/include/openvino/op/loop.hpp index e0e9c1c24bc..e5674531b1e 100644 --- a/src/core/include/openvino/op/loop.hpp +++ b/src/core/include/openvino/op/loop.hpp @@ -15,6 +15,7 @@ namespace ov { namespace op { namespace v5 { /// \brief Iterate a body over tensors, accumulating into tensors. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Loop : public op::util::SubGraphOp { public: /// \brief Allows to define the purpose of inputs/outputs in the body diff --git a/src/core/include/openvino/op/lrn.hpp b/src/core/include/openvino/op/lrn.hpp index f6d2f61abd0..a74e864b3e0 100644 --- a/src/core/include/openvino/op/lrn.hpp +++ b/src/core/include/openvino/op/lrn.hpp @@ -23,6 +23,7 @@ namespace v0 { /// | Type | Description | /// | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | /// | \f$N[n, c, d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[n, c, d_1,\dots,d_n] = \frac{N[n,i,d_1,\dots,d_n]}{ (bias + alpha * (\sum_{i=max(0,(nsize-1)/2)}^{min(C, (nsize-1)/2)+1} N[n,i,d_1,\dots,d_n]^{2}) ^ {2})}\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API LRN : public Op { public: diff --git a/src/core/include/openvino/op/lstm_cell.hpp b/src/core/include/openvino/op/lstm_cell.hpp index 6d5ee0db8f2..5ea57492a51 100644 --- a/src/core/include/openvino/op/lstm_cell.hpp +++ b/src/core/include/openvino/op/lstm_cell.hpp @@ -50,6 +50,7 @@ namespace v0 { /// /// \sa LSTMSequence, RNNCell, GRUCell /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LSTMCell : public util::RNNCellBase { public: OPENVINO_OP("LSTMCell", "opset1", op::util::RNNCellBase); @@ -273,6 +274,7 @@ namespace v4 { /// /// \sa LSTMSequence, RNNCell, GRUCell /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LSTMCell : public util::RNNCellBase { public: OPENVINO_OP("LSTMCell", "opset4", op::util::RNNCellBase, 4); diff --git a/src/core/include/openvino/op/lstm_sequence.hpp b/src/core/include/openvino/op/lstm_sequence.hpp index 8c834a57bbd..194a26f49b1 100644 --- a/src/core/include/openvino/op/lstm_sequence.hpp +++ b/src/core/include/openvino/op/lstm_sequence.hpp @@ -28,6 +28,7 @@ namespace v0 { /// \sa LSTMCell, RNNCell, GRUCell /// /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LSTMSequence : public Op { public: OPENVINO_OP("LSTMSequence", "opset1"); @@ -147,6 +148,7 @@ namespace v5 { /// \sa LSTMCell, RNNCell, GRUCell /// /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API LSTMSequence : public util::RNNCellBase { public: OPENVINO_OP("LSTMSequence", "opset5", util::RNNCellBase, 5); diff --git a/src/core/include/openvino/op/matmul.hpp b/src/core/include/openvino/op/matmul.hpp index 37cdae89ee3..abbba946d41 100644 --- a/src/core/include/openvino/op/matmul.hpp +++ b/src/core/include/openvino/op/matmul.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Operator performing Matrix Multiplication. +/// \ingroup ov_ops_cpp_api class OPENVINO_API MatMul : public Op { public: OPENVINO_OP("MatMul", "opset1"); diff --git a/src/core/include/openvino/op/matrix_nms.hpp b/src/core/include/openvino/op/matrix_nms.hpp index c7cc3412cd4..3ac390a282f 100644 --- a/src/core/include/openvino/op/matrix_nms.hpp +++ b/src/core/include/openvino/op/matrix_nms.hpp @@ -11,6 +11,7 @@ namespace op { namespace v8 { /// \brief MatrixNms operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API MatrixNms : public util::NmsBase { public: OPENVINO_OP("MatrixNms", "opset8", op::util::NmsBase); diff --git a/src/core/include/openvino/op/max_pool.hpp b/src/core/include/openvino/op/max_pool.hpp index 135eadc7505..5591a8f68eb 100644 --- a/src/core/include/openvino/op/max_pool.hpp +++ b/src/core/include/openvino/op/max_pool.hpp @@ -12,6 +12,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Batched max pooling operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API MaxPool : public op::util::MaxPoolBase { public: OPENVINO_OP("MaxPool", "opset1", op::util::MaxPoolBase, 1); @@ -60,6 +61,7 @@ private: namespace v8 { /// \brief MaxPooling operation with values and indices calculated as individual outputs +/// \ingroup ov_ops_cpp_api class OPENVINO_API MaxPool : public op::util::MaxPoolBase { public: OPENVINO_OP("MaxPool", "opset8", op::util::MaxPoolBase); diff --git a/src/core/include/openvino/op/maximum.hpp b/src/core/include/openvino/op/maximum.hpp index d91d47dcb0b..9bdcbe4fa5c 100644 --- a/src/core/include/openvino/op/maximum.hpp +++ b/src/core/include/openvino/op/maximum.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise maximum operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Maximum : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Maximum", "opset1", op::util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/minimum.hpp b/src/core/include/openvino/op/minimum.hpp index 1a5e4d6aa17..65536194eaf 100644 --- a/src/core/include/openvino/op/minimum.hpp +++ b/src/core/include/openvino/op/minimum.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise minimum operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Minimum : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Minimum", "opset1", op::util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/mish.hpp b/src/core/include/openvino/op/mish.hpp index d9833684302..164af705456 100644 --- a/src/core/include/openvino/op/mish.hpp +++ b/src/core/include/openvino/op/mish.hpp @@ -12,6 +12,7 @@ namespace v4 { /// \brief A Self Regularized Non-Monotonic Neural Activation Function /// f(x) = x * tanh(log(exp(x) + 1.)) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Mish : public Op { public: OPENVINO_OP("Mish", "opset4", op::Op, 4); diff --git a/src/core/include/openvino/op/mod.hpp b/src/core/include/openvino/op/mod.hpp index fca0cc14411..9f8c8748fa2 100644 --- a/src/core/include/openvino/op/mod.hpp +++ b/src/core/include/openvino/op/mod.hpp @@ -11,6 +11,7 @@ namespace op { namespace v1 { /// \brief Mod returns an element-wise division reminder with two given tensors applying /// multi-directional broadcast rules. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Mod : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Mod", "opset1", op::util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/multiclass_nms.hpp b/src/core/include/openvino/op/multiclass_nms.hpp index 6cfaaf73a55..4c0c4128a29 100644 --- a/src/core/include/openvino/op/multiclass_nms.hpp +++ b/src/core/include/openvino/op/multiclass_nms.hpp @@ -11,6 +11,7 @@ namespace op { namespace v8 { /// \brief MulticlassNms operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API MulticlassNms : public util::NmsBase { public: OPENVINO_OP("MulticlassNms", "opset8", op::util::NmsBase); diff --git a/src/core/include/openvino/op/multiply.hpp b/src/core/include/openvino/op/multiply.hpp index bb6386d9c2c..592661cfe38 100644 --- a/src/core/include/openvino/op/multiply.hpp +++ b/src/core/include/openvino/op/multiply.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise multiplication operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Multiply : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Multiply", "opset1", util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/mvn.hpp b/src/core/include/openvino/op/mvn.hpp index 00d4f571e8b..df87896f986 100644 --- a/src/core/include/openvino/op/mvn.hpp +++ b/src/core/include/openvino/op/mvn.hpp @@ -14,6 +14,7 @@ namespace op { namespace v0 { /// \brief Operator performing Mean Variance Normalization /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API MVN : public Op { public: OPENVINO_OP("MVN", "opset2"); @@ -87,6 +88,7 @@ std::ostream& operator<<(std::ostream& s, const MVNEpsMode& type); namespace v6 { /// \brief Operator performing Mean Variance Normalization /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API MVN : public Op { public: OPENVINO_OP("MVN", "opset6", op::Op, 6); diff --git a/src/core/include/openvino/op/negative.hpp b/src/core/include/openvino/op/negative.hpp index 5e220eedad9..d083cf1ffe0 100644 --- a/src/core/include/openvino/op/negative.hpp +++ b/src/core/include/openvino/op/negative.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise negative operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Negative : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Negative", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/non_max_suppression.hpp b/src/core/include/openvino/op/non_max_suppression.hpp index fd159307c3d..c83e00acc7c 100644 --- a/src/core/include/openvino/op/non_max_suppression.hpp +++ b/src/core/include/openvino/op/non_max_suppression.hpp @@ -11,6 +11,7 @@ namespace op { namespace v1 { /// \brief Elementwise addition operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NonMaxSuppression : public Op { public: enum class BoxEncodingType { CORNER, CENTER }; @@ -81,6 +82,7 @@ private: namespace v3 { /// \brief NonMaxSuppression operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NonMaxSuppression : public Op { public: enum class BoxEncodingType { CORNER, CENTER }; @@ -163,6 +165,7 @@ protected: namespace v4 { /// \brief NonMaxSuppression operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NonMaxSuppression : public op::v3::NonMaxSuppression { public: OPENVINO_OP("NonMaxSuppression", "opset4", op::v3::NonMaxSuppression, 4); @@ -214,6 +217,7 @@ public: namespace v5 { /// \brief NonMaxSuppression operation /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NonMaxSuppression : public Op { public: OPENVINO_OP("NonMaxSuppression", "opset5", op::Op, 5); diff --git a/src/core/include/openvino/op/non_zero.hpp b/src/core/include/openvino/op/non_zero.hpp index 955ee547a29..a7850a129ab 100644 --- a/src/core/include/openvino/op/non_zero.hpp +++ b/src/core/include/openvino/op/non_zero.hpp @@ -17,6 +17,7 @@ namespace v3 { /// [0, 1, 1], /// [0, 1, 2]] /// The values point to input elements at [0,0,0], [0,1,1] and [2,1,2] +/// \ingroup ov_ops_cpp_api class OPENVINO_API NonZero : public Op { public: OPENVINO_OP("NonZero", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/normalize_l2.hpp b/src/core/include/openvino/op/normalize_l2.hpp index 03d663abd60..9623a3dfdab 100644 --- a/src/core/include/openvino/op/normalize_l2.hpp +++ b/src/core/include/openvino/op/normalize_l2.hpp @@ -14,6 +14,7 @@ namespace op { namespace v0 { /// \brief Normalization with L2 norm. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NormalizeL2 : public Op { public: OPENVINO_OP("NormalizeL2", "opset1"); diff --git a/src/core/include/openvino/op/not_equal.hpp b/src/core/include/openvino/op/not_equal.hpp index b8c5a23ee0a..859f604e5c1 100644 --- a/src/core/include/openvino/op/not_equal.hpp +++ b/src/core/include/openvino/op/not_equal.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise not-equal operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API NotEqual : public util::BinaryElementwiseComparison { public: OPENVINO_OP("NotEqual", "opset1", op::util::BinaryElementwiseComparison, 1); diff --git a/src/core/include/openvino/op/nv12_to_bgr.hpp b/src/core/include/openvino/op/nv12_to_bgr.hpp index 632963cfac7..536c1869354 100644 --- a/src/core/include/openvino/op/nv12_to_bgr.hpp +++ b/src/core/include/openvino/op/nv12_to_bgr.hpp @@ -29,6 +29,7 @@ namespace v8 { /// B = 1.164 * (Y - 16) + 2.018 * (U - 128) /// Then R, G, B values are clipped to range (0, 255) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NV12toBGR : public util::ConvertColorNV12Base { public: OPENVINO_OP("NV12toBGR", "opset8", util::ConvertColorNV12Base); diff --git a/src/core/include/openvino/op/nv12_to_rgb.hpp b/src/core/include/openvino/op/nv12_to_rgb.hpp index d28b3739c11..c52892d3e20 100644 --- a/src/core/include/openvino/op/nv12_to_rgb.hpp +++ b/src/core/include/openvino/op/nv12_to_rgb.hpp @@ -29,6 +29,7 @@ namespace v8 { /// B = 1.164 * (Y - 16) + 2.018 * (U - 128) /// Then R, G, B values are clipped to range (0, 255) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API NV12toRGB : public util::ConvertColorNV12Base { public: OPENVINO_OP("NV12toRGB", "opset8", util::ConvertColorNV12Base); diff --git a/src/core/include/openvino/op/one_hot.hpp b/src/core/include/openvino/op/one_hot.hpp index cc666483ff8..5acf4864abb 100644 --- a/src/core/include/openvino/op/one_hot.hpp +++ b/src/core/include/openvino/op/one_hot.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief OneHot operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API OneHot : public Op { public: OPENVINO_OP("OneHot", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/op.hpp b/src/core/include/openvino/op/op.hpp index e6474946b31..4987d37e558 100644 --- a/src/core/include/openvino/op/op.hpp +++ b/src/core/include/openvino/op/op.hpp @@ -23,7 +23,8 @@ namespace ov { namespace op { -/// Root of all actual ops +/// \brief Root of all actual ops +/// \ingroup ov_ops_cpp_api class OPENVINO_API Op : public Node { protected: Op() : Node() {} diff --git a/src/core/include/openvino/op/pad.hpp b/src/core/include/openvino/op/pad.hpp index 07d87989eea..a66835c4317 100644 --- a/src/core/include/openvino/op/pad.hpp +++ b/src/core/include/openvino/op/pad.hpp @@ -12,6 +12,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Generic padding operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Pad : public Op { public: OPENVINO_OP("Pad", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/parameter.hpp b/src/core/include/openvino/op/parameter.hpp index b6ede9bcd8d..63207276b8d 100644 --- a/src/core/include/openvino/op/parameter.hpp +++ b/src/core/include/openvino/op/parameter.hpp @@ -15,6 +15,7 @@ namespace v0 { /// Parameters are nodes that represent the arguments that will be passed to /// user-defined models. Model creation requires a sequence of parameters. /// Basic graph operations do not need parameters attached to a model. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Parameter : public op::Op { public: OPENVINO_OP("Parameter", "opset1"); diff --git a/src/core/include/openvino/op/power.hpp b/src/core/include/openvino/op/power.hpp index 624850d54f0..8bdac461a2c 100644 --- a/src/core/include/openvino/op/power.hpp +++ b/src/core/include/openvino/op/power.hpp @@ -24,6 +24,7 @@ namespace v1 { /// | Type | Description | /// | ---------------------- | -------------------------------------------------------------------------------------------------------------- | /// | \f$N[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \texttt{arg0}[i_1,\dots,i_n]^{\texttt{arg1}[i_1,\dots,i_n]}\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API Power : public util::BinaryElementwiseArithmetic { public: diff --git a/src/core/include/openvino/op/prelu.hpp b/src/core/include/openvino/op/prelu.hpp index 43b1f8b5593..10c5118a067 100644 --- a/src/core/include/openvino/op/prelu.hpp +++ b/src/core/include/openvino/op/prelu.hpp @@ -13,6 +13,7 @@ namespace v0 { /// x < 0 => f(x) = x * slope /// x >= 0 => f(x) = x /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API PRelu : public Op { public: OPENVINO_OP("PRelu", "opset1"); diff --git a/src/core/include/openvino/op/prior_box.hpp b/src/core/include/openvino/op/prior_box.hpp index 382959203d7..fa897678c06 100644 --- a/src/core/include/openvino/op/prior_box.hpp +++ b/src/core/include/openvino/op/prior_box.hpp @@ -11,6 +11,7 @@ namespace op { namespace v0 { /// \brief Layer which generates prior boxes of specified sizes /// normalized to input image size +/// \ingroup ov_ops_cpp_api class OPENVINO_API PriorBox : public Op { public: OPENVINO_OP("PriorBox", "opset1"); @@ -70,6 +71,7 @@ private: namespace v8 { /// \brief Layer which generates prior boxes of specified sizes /// normalized to input image size +/// \ingroup ov_ops_cpp_api class OPENVINO_API PriorBox : public Op { public: OPENVINO_OP("PriorBox", "opset8"); diff --git a/src/core/include/openvino/op/prior_box_clustered.hpp b/src/core/include/openvino/op/prior_box_clustered.hpp index 471d2b6c733..725a8ec6e4c 100644 --- a/src/core/include/openvino/op/prior_box_clustered.hpp +++ b/src/core/include/openvino/op/prior_box_clustered.hpp @@ -12,6 +12,7 @@ namespace op { namespace v0 { /// \brief Layer which generates prior boxes of specified sizes /// normalized to input image size +/// \ingroup ov_ops_cpp_api class OPENVINO_API PriorBoxClustered : public Op { public: OPENVINO_OP("PriorBoxClustered", "opset1"); diff --git a/src/core/include/openvino/op/proposal.hpp b/src/core/include/openvino/op/proposal.hpp index 3e47df38376..a3a8326d703 100644 --- a/src/core/include/openvino/op/proposal.hpp +++ b/src/core/include/openvino/op/proposal.hpp @@ -10,6 +10,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief Proposal operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Proposal : public Op { public: OPENVINO_OP("Proposal", "opset1"); @@ -71,6 +74,9 @@ protected: } // namespace v0 namespace v4 { +/// \brief Proposal operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Proposal : public op::v0::Proposal { public: OPENVINO_OP("Proposal", "opset4", op::Op, 4); diff --git a/src/core/include/openvino/op/psroi_pooling.hpp b/src/core/include/openvino/op/psroi_pooling.hpp index e8caf5f6827..1ea8ca18263 100644 --- a/src/core/include/openvino/op/psroi_pooling.hpp +++ b/src/core/include/openvino/op/psroi_pooling.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief PSROIPooling operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API PSROIPooling : public Op { public: OPENVINO_OP("PSROIPooling", "opset1"); diff --git a/src/core/include/openvino/op/random_uniform.hpp b/src/core/include/openvino/op/random_uniform.hpp index 533bb230ce2..4cbdea2d312 100644 --- a/src/core/include/openvino/op/random_uniform.hpp +++ b/src/core/include/openvino/op/random_uniform.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v8 { /// \brief Tensor RandomUniform operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API RandomUniform : public Op { public: OPENVINO_OP("RandomUniform", "opset8"); diff --git a/src/core/include/openvino/op/range.hpp b/src/core/include/openvino/op/range.hpp index f5e264500c5..c61d398d07e 100644 --- a/src/core/include/openvino/op/range.hpp +++ b/src/core/include/openvino/op/range.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v4 { /// \brief Range operation, analogous to `arange()` in Numpy. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Range : public Op { public: OPENVINO_OP("Range", "opset4", op::Op, 4); @@ -53,6 +54,7 @@ private: } // namespace v4 namespace v0 { /// \brief Range operation, analogous to `range()` in Python. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Range : public Op { public: OPENVINO_OP("Range", "opset1"); diff --git a/src/core/include/openvino/op/read_value.hpp b/src/core/include/openvino/op/read_value.hpp index 87f2ec56557..8b2734402c0 100644 --- a/src/core/include/openvino/op/read_value.hpp +++ b/src/core/include/openvino/op/read_value.hpp @@ -12,6 +12,7 @@ namespace op { namespace v3 { /// \brief ReadValue operation creates the variable with `variable_id` and returns value /// of this variable. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReadValue : public util::ReadValueBase { public: OPENVINO_OP("ReadValue", "opset3", util::ReadValueBase, 3); @@ -42,6 +43,7 @@ private: namespace v6 { /// \brief ReadValue operation gets an input value from the variable with `variable_id` /// and returns it as an output. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReadValue : public util::ReadValueBase { public: OPENVINO_OP("ReadValue", "opset6", util::ReadValueBase, 6); diff --git a/src/core/include/openvino/op/reduce_l1.hpp b/src/core/include/openvino/op/reduce_l1.hpp index cbed140111f..75fd5a42e73 100644 --- a/src/core/include/openvino/op/reduce_l1.hpp +++ b/src/core/include/openvino/op/reduce_l1.hpp @@ -13,6 +13,7 @@ namespace v4 { /// specified for the normalisation. /// /// Reduces the tensor, eliminating the specified reduction axes by taking the L1-norm. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceL1 : public util::ArithmeticReductionKeepDims { public: OPENVINO_OP("ReduceL1", "opset4", util::ArithmeticReductionKeepDims, 4); diff --git a/src/core/include/openvino/op/reduce_l2.hpp b/src/core/include/openvino/op/reduce_l2.hpp index 8150c6777ea..fca0978730c 100644 --- a/src/core/include/openvino/op/reduce_l2.hpp +++ b/src/core/include/openvino/op/reduce_l2.hpp @@ -12,6 +12,7 @@ namespace v4 { /// \brief Reduction operation using L2 norm: /// /// Reduces the tensor, eliminating the specified reduction axes by taking the L2-norm. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceL2 : public util::ArithmeticReductionKeepDims { public: OPENVINO_OP("ReduceL2", "opset4", util::ArithmeticReductionKeepDims, 4); diff --git a/src/core/include/openvino/op/reduce_logical_and.hpp b/src/core/include/openvino/op/reduce_logical_and.hpp index 6522f91a8b9..c8e43109091 100644 --- a/src/core/include/openvino/op/reduce_logical_and.hpp +++ b/src/core/include/openvino/op/reduce_logical_and.hpp @@ -13,6 +13,7 @@ namespace v1 { /// /// The reduction is performed over slices of the first input. The slices shape depends /// on the values passed to the second input - the axes. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceLogicalAnd : public util::LogicalReductionKeepDims { public: OPENVINO_OP("ReduceLogicalAnd", "opset1", util::LogicalReductionKeepDims, 1); diff --git a/src/core/include/openvino/op/reduce_logical_or.hpp b/src/core/include/openvino/op/reduce_logical_or.hpp index 13d773a6cfb..d3eaac340fb 100644 --- a/src/core/include/openvino/op/reduce_logical_or.hpp +++ b/src/core/include/openvino/op/reduce_logical_or.hpp @@ -13,6 +13,7 @@ namespace v1 { /// /// The reduction is performed over slices of the first input. The slices shape depends /// on the values passed to the second input - the axes. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceLogicalOr : public util::LogicalReductionKeepDims { public: OPENVINO_OP("ReduceLogicalOr", "opset1", util::LogicalReductionKeepDims, 1); diff --git a/src/core/include/openvino/op/reduce_max.hpp b/src/core/include/openvino/op/reduce_max.hpp index 197e87abda0..433e1192077 100644 --- a/src/core/include/openvino/op/reduce_max.hpp +++ b/src/core/include/openvino/op/reduce_max.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief ReduceMax operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceMax : public util::ArithmeticReductionKeepDims { public: OPENVINO_OP("ReduceMax", "opset1", util::ArithmeticReductionKeepDims, 1); diff --git a/src/core/include/openvino/op/reduce_mean.hpp b/src/core/include/openvino/op/reduce_mean.hpp index c05d58393b5..b0e3ad9bff7 100644 --- a/src/core/include/openvino/op/reduce_mean.hpp +++ b/src/core/include/openvino/op/reduce_mean.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief ReduceMean operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceMean : public util::ArithmeticReductionKeepDims { public: OPENVINO_OP("ReduceMean", "opset1", util::ArithmeticReductionKeepDims, 1); diff --git a/src/core/include/openvino/op/reduce_min.hpp b/src/core/include/openvino/op/reduce_min.hpp index c29ecc0e4bc..0eb83503932 100644 --- a/src/core/include/openvino/op/reduce_min.hpp +++ b/src/core/include/openvino/op/reduce_min.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief ReduceMin operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceMin : public util::ArithmeticReductionKeepDims { public: OPENVINO_OP("ReduceMin", "opset1", util::ArithmeticReductionKeepDims, 1); diff --git a/src/core/include/openvino/op/reduce_prod.hpp b/src/core/include/openvino/op/reduce_prod.hpp index ec85a0318c2..cae770880ee 100644 --- a/src/core/include/openvino/op/reduce_prod.hpp +++ b/src/core/include/openvino/op/reduce_prod.hpp @@ -12,6 +12,7 @@ namespace v1 { /// \brief Product reduction operation. /// /// Reduces the tensor, eliminating the specified reduction axes by taking the product. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReduceProd : public util::ArithmeticReductionKeepDims { public: OPENVINO_OP("ReduceProd", "opset1", util::ArithmeticReductionKeepDims, 1); diff --git a/src/core/include/openvino/op/reduce_sum.hpp b/src/core/include/openvino/op/reduce_sum.hpp index 738aba78cae..d1753a20a6b 100644 --- a/src/core/include/openvino/op/reduce_sum.hpp +++ b/src/core/include/openvino/op/reduce_sum.hpp @@ -57,6 +57,7 @@ namespace v1 { /// | Type | Description | /// | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | /// | \f$N[\textit{delete}(A,d_1,\dots,d_n)]\f$ | The tensor \f$T\f$, where \f$T\f$ is the input tensor with the `reduction_axes` \f$A\f$ eliminated by summation. | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API ReduceSum : public util::ArithmeticReductionKeepDims { public: diff --git a/src/core/include/openvino/op/region_yolo.hpp b/src/core/include/openvino/op/region_yolo.hpp index 13aa070828f..043637cffeb 100644 --- a/src/core/include/openvino/op/region_yolo.hpp +++ b/src/core/include/openvino/op/region_yolo.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief RegionYolo operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API RegionYolo : public Op { public: OPENVINO_OP("RegionYolo", "opset1"); diff --git a/src/core/include/openvino/op/relu.hpp b/src/core/include/openvino/op/relu.hpp index 268218285e1..0243a65f191 100644 --- a/src/core/include/openvino/op/relu.hpp +++ b/src/core/include/openvino/op/relu.hpp @@ -13,6 +13,7 @@ namespace op { namespace v0 { /// \brief Elementwise Relu operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Relu : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Relu", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/reorg_yolo.hpp b/src/core/include/openvino/op/reorg_yolo.hpp index 7772194ed92..46c43a323d3 100644 --- a/src/core/include/openvino/op/reorg_yolo.hpp +++ b/src/core/include/openvino/op/reorg_yolo.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief ReorgYolo operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReorgYolo : public Op { public: OPENVINO_OP("ReorgYolo", "opset2"); diff --git a/src/core/include/openvino/op/reshape.hpp b/src/core/include/openvino/op/reshape.hpp index cb50ff67e4a..838e91b1079 100644 --- a/src/core/include/openvino/op/reshape.hpp +++ b/src/core/include/openvino/op/reshape.hpp @@ -14,6 +14,7 @@ namespace v1 { /// "Converts" an input tensor into a new shape with the same number of elements. /// This op does not touch the actual data. If needed, use Transpose for that purpose. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Reshape : public Op { public: OPENVINO_OP("Reshape", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/result.hpp b/src/core/include/openvino/op/result.hpp index da0afc30d1a..0693429d683 100644 --- a/src/core/include/openvino/op/result.hpp +++ b/src/core/include/openvino/op/result.hpp @@ -10,6 +10,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief Result operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Result : public Op { public: OPENVINO_OP("Result", "opset1"); diff --git a/src/core/include/openvino/op/reverse.hpp b/src/core/include/openvino/op/reverse.hpp index 295f3dad55e..d3b8e137371 100644 --- a/src/core/include/openvino/op/reverse.hpp +++ b/src/core/include/openvino/op/reverse.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief Reverse operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Reverse : public Op { public: OPENVINO_OP("Reverse", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/reverse_sequence.hpp b/src/core/include/openvino/op/reverse_sequence.hpp index 089c851b82a..5e2683f67fe 100644 --- a/src/core/include/openvino/op/reverse_sequence.hpp +++ b/src/core/include/openvino/op/reverse_sequence.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief ReverseSequence operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ReverseSequence : public Op { public: OPENVINO_OP("ReverseSequence", "opset1"); diff --git a/src/core/include/openvino/op/rnn_cell.hpp b/src/core/include/openvino/op/rnn_cell.hpp index 27a1bd321b1..0e607630f74 100644 --- a/src/core/include/openvino/op/rnn_cell.hpp +++ b/src/core/include/openvino/op/rnn_cell.hpp @@ -34,6 +34,7 @@ namespace v0 { /// /// \sa LSTMSequence, LSTMCell, GRUCell /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API RNNCell : public util::RNNCellBase { public: OPENVINO_OP("RNNCell", "opset1", util::RNNCellBase); diff --git a/src/core/include/openvino/op/rnn_sequence.hpp b/src/core/include/openvino/op/rnn_sequence.hpp index 72c3573f1f1..7efb217b247 100644 --- a/src/core/include/openvino/op/rnn_sequence.hpp +++ b/src/core/include/openvino/op/rnn_sequence.hpp @@ -13,6 +13,9 @@ namespace ov { namespace op { namespace v5 { +/// \brief RNNSequence operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API RNNSequence : public util::RNNCellBase { public: OPENVINO_OP("RNNSequence", "opset5", util::RNNCellBase, 4); diff --git a/src/core/include/openvino/op/roi_align.hpp b/src/core/include/openvino/op/roi_align.hpp index fbe7666fccf..bf8842892fc 100644 --- a/src/core/include/openvino/op/roi_align.hpp +++ b/src/core/include/openvino/op/roi_align.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v3 { +/// \brief ROIAlign operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ROIAlign : public Op { public: OPENVINO_OP("ROIAlign", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/roi_pooling.hpp b/src/core/include/openvino/op/roi_pooling.hpp index 8b66f63c59d..f90cda5a524 100644 --- a/src/core/include/openvino/op/roi_pooling.hpp +++ b/src/core/include/openvino/op/roi_pooling.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief ROIPooling operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ROIPooling : public Op { public: OPENVINO_OP("ROIPooling", "opset2"); diff --git a/src/core/include/openvino/op/roll.hpp b/src/core/include/openvino/op/roll.hpp index c8e018348d9..99586a0c405 100644 --- a/src/core/include/openvino/op/roll.hpp +++ b/src/core/include/openvino/op/roll.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v7 { /// \brief Tensor roll operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Roll : public Op { public: OPENVINO_OP("Roll", "opset7", op::Op, 7); diff --git a/src/core/include/openvino/op/round.hpp b/src/core/include/openvino/op/round.hpp index 154c7c5038b..a8307145e80 100644 --- a/src/core/include/openvino/op/round.hpp +++ b/src/core/include/openvino/op/round.hpp @@ -14,6 +14,7 @@ namespace v5 { /// 'HALF_TO_EVEN' - round halfs to the nearest even integer. /// 'HALF_AWAY_FROM_ZERO': - round in such a way that the result heads away from /// zero. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Round : public Op { public: enum class RoundMode { HALF_TO_EVEN, HALF_AWAY_FROM_ZERO }; diff --git a/src/core/include/openvino/op/scatter_elements_update.hpp b/src/core/include/openvino/op/scatter_elements_update.hpp index fd9f97adb38..e8c0e1f216b 100644 --- a/src/core/include/openvino/op/scatter_elements_update.hpp +++ b/src/core/include/openvino/op/scatter_elements_update.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v3 { +/// \brief ScatterElementsUpdate operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ScatterElementsUpdate : public Op { public: OPENVINO_OP("ScatterElementsUpdate", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/scatter_nd_update.hpp b/src/core/include/openvino/op/scatter_nd_update.hpp index 19d4b0c5466..f8b0ed49e50 100644 --- a/src/core/include/openvino/op/scatter_nd_update.hpp +++ b/src/core/include/openvino/op/scatter_nd_update.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Add updates to slices from inputs addressed by indices +/// \ingroup ov_ops_cpp_api class OPENVINO_API ScatterNDUpdate : public util::ScatterNDBase { public: OPENVINO_OP("ScatterNDUpdate", "opset4", util::ScatterNDBase, 3); diff --git a/src/core/include/openvino/op/scatter_update.hpp b/src/core/include/openvino/op/scatter_update.hpp index 42f928eb52c..1c0116bb83c 100644 --- a/src/core/include/openvino/op/scatter_update.hpp +++ b/src/core/include/openvino/op/scatter_update.hpp @@ -12,6 +12,7 @@ namespace v3 { /// /// \brief Set new values to slices from data addressed by indices /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API ScatterUpdate : public util::ScatterBase { public: OPENVINO_OP("ScatterUpdate", "opset3", util::ScatterBase, 3); diff --git a/src/core/include/openvino/op/select.hpp b/src/core/include/openvino/op/select.hpp index 5b92a9c25c8..5406ea3bac6 100644 --- a/src/core/include/openvino/op/select.hpp +++ b/src/core/include/openvino/op/select.hpp @@ -26,6 +26,7 @@ namespace v1 { /// | Type | Description | /// | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | /// | \f$E[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \texttt{arg1}[i_1,\dots,i_n]\text{ if }\texttt{arg0}[i_1,\dots,i_n] \neq 0\text{, else }\texttt{arg2}[i_1,\dots,i_n]\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API Select : public Op { public: diff --git a/src/core/include/openvino/op/selu.hpp b/src/core/include/openvino/op/selu.hpp index af6e61e97ca..3a42987c4ce 100644 --- a/src/core/include/openvino/op/selu.hpp +++ b/src/core/include/openvino/op/selu.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Performs a SELU activation function on all elements of the input node +/// \ingroup ov_ops_cpp_api class OPENVINO_API Selu : public Op { public: OPENVINO_OP("Selu", "opset1"); diff --git a/src/core/include/openvino/op/shape_of.hpp b/src/core/include/openvino/op/shape_of.hpp index d12e6ebe50e..6201411c9a0 100644 --- a/src/core/include/openvino/op/shape_of.hpp +++ b/src/core/include/openvino/op/shape_of.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v3 { /// \brief Operation that returns the shape of its input argument as a tensor. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ShapeOf : public Op { public: OPENVINO_OP("ShapeOf", "opset3", op::Op, 3); @@ -50,6 +51,7 @@ private: namespace v0 { /// \brief Operation that returns the shape of its input argument as a tensor. +/// \ingroup ov_ops_cpp_api class OPENVINO_API ShapeOf : public Op { public: OPENVINO_OP("ShapeOf", "opset1"); diff --git a/src/core/include/openvino/op/shuffle_channels.hpp b/src/core/include/openvino/op/shuffle_channels.hpp index af0b208942e..75173c1270b 100644 --- a/src/core/include/openvino/op/shuffle_channels.hpp +++ b/src/core/include/openvino/op/shuffle_channels.hpp @@ -12,6 +12,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Permutes data in the channel dimension of the input +/// \ingroup ov_ops_cpp_api class OPENVINO_API ShuffleChannels : public Op { public: OPENVINO_OP("ShuffleChannels", "opset1"); diff --git a/src/core/include/openvino/op/sigmoid.hpp b/src/core/include/openvino/op/sigmoid.hpp index 1e7bbfb7376..428f256b0d6 100644 --- a/src/core/include/openvino/op/sigmoid.hpp +++ b/src/core/include/openvino/op/sigmoid.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief Sigmoid operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Sigmoid : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Sigmoid", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/sign.hpp b/src/core/include/openvino/op/sign.hpp index da4bbe4500f..abb8701635f 100644 --- a/src/core/include/openvino/op/sign.hpp +++ b/src/core/include/openvino/op/sign.hpp @@ -11,6 +11,7 @@ namespace op { namespace v0 { /// \brief Elementwise sign operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Sign : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Sign", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/sin.hpp b/src/core/include/openvino/op/sin.hpp index a1f39489519..53a53725966 100644 --- a/src/core/include/openvino/op/sin.hpp +++ b/src/core/include/openvino/op/sin.hpp @@ -23,6 +23,7 @@ namespace v0 { /// | Type | Description | /// | ---------------------- | ------------------------------------------------------------------------------------ | /// | \f$N[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \sin(\texttt{arg}[i_1,\dots,i_n])\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API Sin : public util::UnaryElementwiseArithmetic { public: diff --git a/src/core/include/openvino/op/sinh.hpp b/src/core/include/openvino/op/sinh.hpp index 6d8571498f2..f904c60bf9e 100644 --- a/src/core/include/openvino/op/sinh.hpp +++ b/src/core/include/openvino/op/sinh.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise hyperbolic sine (sinh) operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Sinh : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Sinh", "opset1", util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/sink.hpp b/src/core/include/openvino/op/sink.hpp index 948b1106a3a..c467df62828 100644 --- a/src/core/include/openvino/op/sink.hpp +++ b/src/core/include/openvino/op/sink.hpp @@ -10,7 +10,8 @@ namespace ov { namespace op { -/// Root of nodes that can be sink nodes +/// \brief Root of nodes that can be sink nodes +/// \ingroup ov_ops_cpp_api class OPENVINO_API Sink : public Op { public: ~Sink() override = 0; diff --git a/src/core/include/openvino/op/slice.hpp b/src/core/include/openvino/op/slice.hpp index 2bcbec3f486..c71cea1d36c 100644 --- a/src/core/include/openvino/op/slice.hpp +++ b/src/core/include/openvino/op/slice.hpp @@ -11,6 +11,7 @@ namespace op { namespace v8 { /// \brief Slice operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Slice : public Op { public: OPENVINO_OP("Slice", "opset8"); diff --git a/src/core/include/openvino/op/softmax.hpp b/src/core/include/openvino/op/softmax.hpp index e8e617c361f..f0f012bffff 100644 --- a/src/core/include/openvino/op/softmax.hpp +++ b/src/core/include/openvino/op/softmax.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v1 { +/// \brief Softmax operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Softmax : public Op { public: OPENVINO_OP("Softmax", "opset1", op::Op, 1); @@ -48,6 +51,7 @@ private: namespace v8 { /// \brief Softmax operation with negative axis values +/// \ingroup ov_ops_cpp_api class OPENVINO_API Softmax : public Op { public: OPENVINO_OP("Softmax", "opset8"); diff --git a/src/core/include/openvino/op/softplus.hpp b/src/core/include/openvino/op/softplus.hpp index e76f6746b72..aac74396deb 100644 --- a/src/core/include/openvino/op/softplus.hpp +++ b/src/core/include/openvino/op/softplus.hpp @@ -12,6 +12,7 @@ namespace v4 { /// \brief A Self Regularized Non-Monotonic Neural Activation Function /// f(x) = ln(exp(x) + 1.) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API SoftPlus : public Op { public: OPENVINO_OP("SoftPlus", "opset4", op::Op, 4); diff --git a/src/core/include/openvino/op/space_to_batch.hpp b/src/core/include/openvino/op/space_to_batch.hpp index da6ca9e83f1..715944b6281 100644 --- a/src/core/include/openvino/op/space_to_batch.hpp +++ b/src/core/include/openvino/op/space_to_batch.hpp @@ -20,6 +20,7 @@ namespace v1 { /// (pads_begin[2] + D_2 + pads_end[2]) / block_shape[2], ..., /// (pads_begin[N - 1] + D_{N - 1} + pads_end[N - 1]) / block_shape[N - 1]` /// of the same type as `data` input. +/// \ingroup ov_ops_cpp_api class OPENVINO_API SpaceToBatch : public Op { public: OPENVINO_OP("SpaceToBatch", "opset2", op::Op, 1); diff --git a/src/core/include/openvino/op/space_to_depth.hpp b/src/core/include/openvino/op/space_to_depth.hpp index 01fb023e246..ec57577f436 100644 --- a/src/core/include/openvino/op/space_to_depth.hpp +++ b/src/core/include/openvino/op/space_to_depth.hpp @@ -16,6 +16,7 @@ namespace v0 { /// /// Output node produces a tensor with shape: /// [N, C * blocksize * blocksize, H / blocksize, W / blocksize] +/// \ingroup ov_ops_cpp_api class OPENVINO_API SpaceToDepth : public Op { public: OPENVINO_OP("SpaceToDepth", "opset1"); diff --git a/src/core/include/openvino/op/split.hpp b/src/core/include/openvino/op/split.hpp index 6f1ea2ce08b..ae376e66600 100644 --- a/src/core/include/openvino/op/split.hpp +++ b/src/core/include/openvino/op/split.hpp @@ -14,6 +14,7 @@ namespace op { namespace v1 { /// \brief Splits the input tensor into a list of equal sized tensors +/// \ingroup ov_ops_cpp_api class OPENVINO_API Split : public Op { public: OPENVINO_OP("Split", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/sqrt.hpp b/src/core/include/openvino/op/sqrt.hpp index 30a0c319f4f..c1433a3df1e 100644 --- a/src/core/include/openvino/op/sqrt.hpp +++ b/src/core/include/openvino/op/sqrt.hpp @@ -23,6 +23,7 @@ namespace v0 { /// | Type | Description | /// | ---------------------- | ------------------------------------------------------------------------------------- | /// | \f$N[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \sqrt{\texttt{arg}[i_1,\dots,i_n]}\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API Sqrt : public util::UnaryElementwiseArithmetic { public: diff --git a/src/core/include/openvino/op/squared_difference.hpp b/src/core/include/openvino/op/squared_difference.hpp index 2d61e30d8aa..061aabb63e1 100644 --- a/src/core/include/openvino/op/squared_difference.hpp +++ b/src/core/include/openvino/op/squared_difference.hpp @@ -12,6 +12,7 @@ namespace v0 { /// \brief Calculates an element-wise squared difference between two tensors /// /// y[i] = (x1[i] - x2[i])^2 +/// \ingroup ov_ops_cpp_api class OPENVINO_API SquaredDifference : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("SquaredDifference", "opset1", util::BinaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/squeeze.hpp b/src/core/include/openvino/op/squeeze.hpp index 5a51d18a278..5445b692413 100644 --- a/src/core/include/openvino/op/squeeze.hpp +++ b/src/core/include/openvino/op/squeeze.hpp @@ -9,6 +9,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief Squeeze operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Squeeze : public Op { public: OPENVINO_OP("Squeeze", "opset1"); diff --git a/src/core/include/openvino/op/strided_slice.hpp b/src/core/include/openvino/op/strided_slice.hpp index cb5b19cde08..daa69ce64ad 100644 --- a/src/core/include/openvino/op/strided_slice.hpp +++ b/src/core/include/openvino/op/strided_slice.hpp @@ -15,6 +15,7 @@ namespace op { namespace v1 { /// \brief Takes a slice of an input tensor, i.e., the sub-tensor that resides within a /// bounding box, optionally with stride. +/// \ingroup ov_ops_cpp_api class OPENVINO_API StridedSlice : public Op { public: OPENVINO_OP("StridedSlice", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/subtract.hpp b/src/core/include/openvino/op/subtract.hpp index 584cbcdcb03..ce48b9cd209 100644 --- a/src/core/include/openvino/op/subtract.hpp +++ b/src/core/include/openvino/op/subtract.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Elementwise subtraction operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Subtract : public util::BinaryElementwiseArithmetic { public: OPENVINO_OP("Subtract", "opset1", util::BinaryElementwiseArithmetic, 1); diff --git a/src/core/include/openvino/op/swish.hpp b/src/core/include/openvino/op/swish.hpp index 92c3a974444..4d33513f548 100644 --- a/src/core/include/openvino/op/swish.hpp +++ b/src/core/include/openvino/op/swish.hpp @@ -13,6 +13,7 @@ namespace v4 { /// f(x) = x / (1.0 + exp(-beta * x)) or /// f(x) = x * sigmoid(beta * x) /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Swish : public Op { public: OPENVINO_OP("Swish", "opset4", op::Op, 4); diff --git a/src/core/include/openvino/op/tan.hpp b/src/core/include/openvino/op/tan.hpp index 3e7457f52ad..87240a2c4f7 100644 --- a/src/core/include/openvino/op/tan.hpp +++ b/src/core/include/openvino/op/tan.hpp @@ -23,6 +23,7 @@ namespace v0 { /// | Type | Description | /// | ---------------------- | ------------------------------------------------------------------------------------ | /// | \f$N[d_1,\dots,d_n]\f$ | The tensor \f$T\f$, where \f$T[i_1,\dots,i_n] = \tan(\texttt{arg}[i_1,\dots,i_n])\f$ | +/// \ingroup ov_ops_cpp_api // clang-format on class OPENVINO_API Tan : public util::UnaryElementwiseArithmetic { public: diff --git a/src/core/include/openvino/op/tanh.hpp b/src/core/include/openvino/op/tanh.hpp index c4606f631f3..98564bd6b33 100644 --- a/src/core/include/openvino/op/tanh.hpp +++ b/src/core/include/openvino/op/tanh.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Elementwise hyperbolic tangent operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Tanh : public util::UnaryElementwiseArithmetic { public: OPENVINO_OP("Tanh", "opset1", op::util::UnaryElementwiseArithmetic); diff --git a/src/core/include/openvino/op/tensor_iterator.hpp b/src/core/include/openvino/op/tensor_iterator.hpp index a87f8712c97..6fd7b25f792 100644 --- a/src/core/include/openvino/op/tensor_iterator.hpp +++ b/src/core/include/openvino/op/tensor_iterator.hpp @@ -14,6 +14,7 @@ namespace ov { namespace op { namespace v0 { /// \brief Iterate a body over tensors, accumulating into tensors. +/// \ingroup ov_ops_cpp_api class OPENVINO_API TensorIterator : public op::util::SubGraphOp { public: OPENVINO_OP("TensorIterator", "opset1", op::util::SubGraphOp); diff --git a/src/core/include/openvino/op/tile.hpp b/src/core/include/openvino/op/tile.hpp index 48d30c9724a..dcf31f9d1da 100644 --- a/src/core/include/openvino/op/tile.hpp +++ b/src/core/include/openvino/op/tile.hpp @@ -11,6 +11,7 @@ namespace op { namespace v0 { /// \brief Dynamic Tiling operation which repeats a tensor multiple times /// along each dimension +/// \ingroup ov_ops_cpp_api class OPENVINO_API Tile : public Op { public: OPENVINO_OP("Tile", "opset1"); diff --git a/src/core/include/openvino/op/topk.hpp b/src/core/include/openvino/op/topk.hpp index d815c1c9157..90aee800224 100644 --- a/src/core/include/openvino/op/topk.hpp +++ b/src/core/include/openvino/op/topk.hpp @@ -14,6 +14,7 @@ namespace op { namespace v1 { /// \brief Computes indices and values of the k maximum/minimum values /// for each slice along specified axis. +/// \ingroup ov_ops_cpp_api class OPENVINO_API TopK : public Op { public: OPENVINO_OP("TopK", "opset1", op::Op, 1); @@ -118,6 +119,7 @@ protected: namespace v3 { /// \brief Computes indices and values of the k maximum/minimum values /// for each slice along specified axis. +/// \ingroup ov_ops_cpp_api class OPENVINO_API TopK : public v1::TopK { public: OPENVINO_OP("TopK", "opset3", op::Op, 3); diff --git a/src/core/include/openvino/op/transpose.hpp b/src/core/include/openvino/op/transpose.hpp index e7048281002..6ecf5cc986e 100644 --- a/src/core/include/openvino/op/transpose.hpp +++ b/src/core/include/openvino/op/transpose.hpp @@ -10,6 +10,7 @@ namespace ov { namespace op { namespace v1 { /// \brief Tensor transpose operation. +/// \ingroup ov_ops_cpp_api class OPENVINO_API Transpose : public Op { public: OPENVINO_OP("Transpose", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/unsqueeze.hpp b/src/core/include/openvino/op/unsqueeze.hpp index b8f90521128..6cc279b329c 100644 --- a/src/core/include/openvino/op/unsqueeze.hpp +++ b/src/core/include/openvino/op/unsqueeze.hpp @@ -11,6 +11,9 @@ namespace ov { namespace op { namespace v0 { +/// \brief Unsqueeze operation. +/// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Unsqueeze : public Op { public: OPENVINO_OP("Unsqueeze", "opset1"); diff --git a/src/core/include/openvino/op/variadic_split.hpp b/src/core/include/openvino/op/variadic_split.hpp index b8f38f2d6fa..f17e81d7cdf 100644 --- a/src/core/include/openvino/op/variadic_split.hpp +++ b/src/core/include/openvino/op/variadic_split.hpp @@ -11,6 +11,7 @@ namespace op { namespace v1 { /// \brief VariadicSplit operation splits an input tensor into pieces along some axis. /// The pieces may have variadic lengths depending on "split_lengths" attribute. +/// \ingroup ov_ops_cpp_api class OPENVINO_API VariadicSplit : public Op { public: OPENVINO_OP("VariadicSplit", "opset1", op::Op, 1); diff --git a/src/core/include/openvino/op/xor.hpp b/src/core/include/openvino/op/xor.hpp index 095d2a7e44b..e248e76b74e 100644 --- a/src/core/include/openvino/op/xor.hpp +++ b/src/core/include/openvino/op/xor.hpp @@ -13,6 +13,7 @@ namespace op { namespace v0 { /// \brief Elementwise logical-xor operation. /// +/// \ingroup ov_ops_cpp_api class OPENVINO_API Xor : public util::BinaryElementwiseLogical { public: OPENVINO_OP("Xor", "opset1", util::BinaryElementwiseLogical); diff --git a/src/core/include/openvino/opsets/opset.hpp b/src/core/include/openvino/opsets/opset.hpp index a45b406ea71..de2bc654ea7 100644 --- a/src/core/include/openvino/opsets/opset.hpp +++ b/src/core/include/openvino/opsets/opset.hpp @@ -16,7 +16,10 @@ #include "openvino/core/node.hpp" namespace ov { -/// \brief Run-time opset information +/** + * @brief Run-time opset information + * @ingroup ov_opset_cpp_api + */ class OPENVINO_API OpSet { static std::mutex& get_mutex(); @@ -128,12 +131,44 @@ protected: } }; +/** + * @brief Returns opset1 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset1(); +/** + * @brief Returns opset2 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset2(); +/** + * @brief Returns opset3 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset3(); +/** + * @brief Returns opset4 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset4(); +/** + * @brief Returns opset5 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset5(); +/** + * @brief Returns opset6 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset6(); +/** + * @brief Returns opset7 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset7(); +/** + * @brief Returns opset8 + * @ingroup ov_opset_cpp_api + */ const OPENVINO_API OpSet& get_opset8(); } // namespace ov