[CPU]: Added ROIAlignRotated basic impl.

src/core/include/openvino/opsets/opset14_tbl.hpp

@@ -221,3 +221,4 @@ _OPENVINO_OP_REG(FakeConvert, ov::op::v13)
 // New operations added in opset14
 _OPENVINO_OP_REG(ConvertPromoteTypes, ov::op::v14)
 _OPENVINO_OP_REG(Inverse, ov::op::v14)
+_OPENVINO_OP_REG(ROIAlignRotated, ov::op::v14)

src/frontends/onnx/tests/onnx_import.in.cpp

@@ -6617,8 +6617,9 @@ OPENVINO_TEST(${BACKEND_NAME}, onnx_model_mish_activation) {
 }
 
 OPENVINO_TEST(${BACKEND_NAME}, onnx_model_mmdeploy_roi_align_rotated) {
-    if (std::string("${BACKEND_NAME}") != std::string("INTERPRETER")) {
-        return;  //< Skip this test for non-INTERPRETER backends, since op is not yet implemented on those backends.
+    if (!(std::string("${BACKEND_NAME}") == std::string("INTERPRETER") ||
+          std::string("${BACKEND_NAME}") == std::string("IE_CPU"))) {
+        return;  //< Skip this test for not-yet-implemented on those backends.
     }
 
     auto model = convert_model("mmdeploy_roi_align_rotated.onnx");

src/plugins/intel_cpu/CMakeLists.txt

@@ -186,6 +186,11 @@ if (ENABLE_SNIPPETS_LIBXSMM_TPP)
     target_include_directories(${TARGET_NAME} SYSTEM PRIVATE $<TARGET_PROPERTY:xsmm,INCLUDE_DIRECTORIES>)
 endif ()
 target_include_directories(${TARGET_NAME} SYSTEM PRIVATE $<TARGET_PROPERTY:dnnl,INCLUDE_DIRECTORIES>)
+
+# Temporal solution to use template reference implementations in cases where optimizied implementation
+# is not (yet) needed.
+target_include_directories(${TARGET_NAME} PRIVATE $<TARGET_PROPERTY:openvino::reference,INTERFACE_INCLUDE_DIRECTORIES>)
+
 # Cross compiled function
 # TODO: The same for proposal, proposalONNX, topk
 cross_compiled_file(${TARGET_NAME}
@@ -249,6 +254,7 @@ if(BUILD_SHARED_LIBS)
             $<TARGET_PROPERTY:openvino::itt,INTERFACE_INCLUDE_DIRECTORIES>
             $<TARGET_PROPERTY:openvino::shape_inference,INTERFACE_INCLUDE_DIRECTORIES>
             $<TARGET_PROPERTY:openvino::snippets,INTERFACE_INCLUDE_DIRECTORIES>
+            $<TARGET_PROPERTY:openvino::reference,INTERFACE_INCLUDE_DIRECTORIES>
         PUBLIC
             ${CMAKE_CURRENT_SOURCE_DIR}/src
             $<TARGET_PROPERTY:openvino::conditional_compilation,INTERFACE_INCLUDE_DIRECTORIES>)

src/plugins/intel_cpu/src/cpu_types.cpp

@@ -116,6 +116,7 @@ static const TypeToNameMap& get_type_to_name_tbl() {
         {"Slice", Type::StridedSlice},
         {"Tile", Type::Tile},
         {"ROIAlign", Type::ROIAlign},
+        {"ROIAlignRotated", Type::ROIAlignRotated},
         {"ROIPooling", Type::ROIPooling},
         {"PSROIPooling", Type::PSROIPooling},
         {"DeformablePSROIPooling", Type::PSROIPooling},
@@ -280,6 +281,7 @@ std::string NameFromType(const Type type) {
         CASE(NonZero);
         CASE(Tile);
         CASE(ROIAlign);
+        CASE(ROIAlignRotated);
         CASE(ROIPooling);
         CASE(PSROIPooling);
         CASE(DepthToSpace);

src/plugins/intel_cpu/src/cpu_types.h

@@ -41,6 +41,7 @@ enum class Type {
     NonZero,
     Tile,
     ROIAlign,
+    ROIAlignRotated,
     ROIPooling,
     PSROIPooling,
     BatchToSpace,

src/plugins/intel_cpu/src/nodes/roi_align_rotated.cpp

@@ -0,0 +1,110 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "roi_align_rotated.h"
+
+#include <openvino/opsets/opset14.hpp>
+
+#include "common/cpu_convert.h"
+#include "openvino/reference/roi_align.hpp"
+
+namespace ov {
+namespace intel_cpu {
+namespace node {
+
+ROIAlignRotated::ROIAlignRotated(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, NgraphShapeInferFactory(op, EMPTY_PORT_MASK)) {
+    std::string errorMessage;
+    const auto roiAlign = ov::as_type_ptr<const ov::opset14::ROIAlignRotated>(op);
+    pooledH = roiAlign->get_pooled_h();
+    pooledW = roiAlign->get_pooled_w();
+    spatialScale = roiAlign->get_spatial_scale();
+    samplingRatio = roiAlign->get_sampling_ratio();
+    clockwiseMode = roiAlign->get_clockwise_mode();
+}
+
+void ROIAlignRotated::getSupportedDescriptors() {
+    // Validation is already done in the ov::opset14::ROIAlignRotated.
+}
+
+void ROIAlignRotated::initSupportedPrimitiveDescriptors() {
+    if (!supportedPrimitiveDescriptors.empty())
+        return;
+
+    ov::element::Type inputPrec0 = getOriginalInputPrecisionAtPort(0);
+    ov::element::Type outputPrec = getOriginalOutputPrecisionAtPort(0);
+
+    addSupportedPrimDesc(
+        {{LayoutType::ncsp, inputPrec0}, {LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::i32}},
+        {{LayoutType::ncsp, outputPrec}},
+        impl_desc_type::ref);
+}
+
+bool ROIAlignRotated::created() const {
+    return getType() == Type::ROIAlignRotated;
+}
+
+bool ROIAlignRotated::needPrepareParams() const {
+    return false;
+}
+
+void ROIAlignRotated::executeDynamicImpl(dnnl::stream strm) {
+    execute(strm);
+}
+
+template <ov::element::Type_t OV_TYPE>
+void ROIAlignRotated::executeImpl() {
+    using T = typename ov::element_type_traits<OV_TYPE>::value_type;
+
+    const size_t batch_indices_size = getSrcMemoryAtPort(2)->getShape().getElementsCount();
+
+    std::vector<int64_t> batch_indices_vec_scaled_up(batch_indices_size);
+    cpu_convert(getSrcMemoryAtPort(2)->getData(),
+                batch_indices_vec_scaled_up.data(),
+                getSrcMemoryAtPort(2)->getPrecision(),
+                ov::element::i64,
+                batch_indices_size);
+
+    ov::reference::roi_align<T, ov::reference::roi_policy::ROIAlignRotatedOpDefPolicy>(
+        getSrcDataAtPortAs<const T>(0),
+        getSrcDataAtPortAs<const T>(1),
+        batch_indices_vec_scaled_up.data(),
+        getDstDataAtPortAs<T>(0),
+        getSrcMemoryAtPort(0)->getShape().toPartialShape().to_shape(),  //< Conversion from intel_cpu::Shape to
+                                                                        // ov::Shape....
+        getSrcMemoryAtPort(1)->getShape().toPartialShape().to_shape(),
+        getSrcMemoryAtPort(2)->getShape().toPartialShape().to_shape(),
+        getDstMemoryAtPort(0)->getShape().toPartialShape().to_shape(),
+        pooledH,
+        pooledW,
+        samplingRatio,
+        spatialScale,
+        ov::op::v3::ROIAlign::PoolingMode::AVG,
+        ov::op::v9::ROIAlign::AlignedMode::ASYMMETRIC,
+        clockwiseMode);
+}
+
+void ROIAlignRotated::execute(dnnl::stream) {
+    const ov::element::Type type = getOriginalInputPrecisionAtPort(0);
+    executeImpl<ov::element::f32>();
+
+#define CASE(OV_TYPE)                        \
+    case ov::element::OV_TYPE:               \
+        executeImpl<ov::element::OV_TYPE>(); \
+        break;
+
+    switch (type) {
+        CASE(bf16);
+        CASE(f16);
+        CASE(f32);
+        CASE(f64);
+    default:
+        OPENVINO_THROW("[ROIAlignRotated]: Unhandled data type ", type, " in execute()");
+    }
+#undef CASE
+}
+
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov

src/plugins/intel_cpu/src/nodes/roi_align_rotated.h

@@ -0,0 +1,37 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "node.h"
+
+namespace ov {
+namespace intel_cpu {
+namespace node {
+
+class ROIAlignRotated : public Node {
+public:
+    ROIAlignRotated(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
+
+    void getSupportedDescriptors() override;
+    void initSupportedPrimitiveDescriptors() override;
+    void execute(dnnl::stream strm) override;
+    bool created() const override;
+    bool needPrepareParams() const override;
+    void executeDynamicImpl(dnnl::stream strm) override;
+
+private:
+    template <ov::element::Type_t OV_TYPE>
+    void executeImpl();
+
+    int pooledH;
+    int pooledW;
+    int samplingRatio;
+    float spatialScale;
+    bool clockwiseMode;
+};
+
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov

src/plugins/intel_cpu/src/nodes_factory.cpp

@@ -78,6 +78,7 @@
 #include "nodes/reverse_sequence.h"
 #include "nodes/rnn.h"
 #include "nodes/roi_align.h"
+#include "nodes/roi_align_rotated.h"
 #include "nodes/roi_pooling.h"
 #include "nodes/roll.h"
 #include "nodes/rope.h"
@@ -193,6 +194,7 @@ Node::NodesFactory::NodesFactory() : Factory("NodesFactory") {
     INTEL_CPU_NODE(NonMaxSuppression, Type::NonMaxSuppression);
     INTEL_CPU_NODE(ROIPooling, Type::ROIPooling);
     INTEL_CPU_NODE(ROIAlign, Type::ROIAlign);
+    INTEL_CPU_NODE(ROIAlignRotated, Type::ROIAlignRotated);
     INTEL_CPU_NODE(TopK, Type::TopK);
     INTEL_CPU_NODE(Proposal, Type::Proposal);
     INTEL_CPU_NODE(RegionYolo, Type::RegionYolo);