[CPU]: Added ROIAlignRotated basic impl.

src/core/include/openvino/op/roi_align_rotated.hpp

@@ -38,6 +38,8 @@ class OPENVINO_API ROIAlignRotated : public util::ROIAlignBase {
                     const float spatial_scale,
                     const bool clockwise_mode);
 
+    bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
+    bool has_evaluate() const override;
     void validate_and_infer_types() override;
     bool visit_attributes(AttributeVisitor& visitor) override;
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;

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/core/src/op/roi_align_rotated.cpp

@@ -4,11 +4,52 @@
 
 #include "openvino/op/roi_align_rotated.hpp"
 
+#include "element_visitor.hpp"
 #include "itt.hpp"
+#include "openvino/reference/roi_align.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace op {
 namespace v14 {
+
+namespace helpers {
+struct Evaluate : element::NoAction<bool> {
+    using element::NoAction<bool>::visit;
+
+    template <element::Type_t ET>
+    static result_type visit(const Tensor& input,
+                             const Tensor& rois,
+                             const Tensor& batch_indices,
+                             Tensor& out,
+                             int pooled_h,
+                             int pooled_w,
+                             int sampling_ratio,
+                             float spatial_scale,
+                             bool clockwise_mode) {
+        using T = fundamental_type_for<ET>;
+        const auto batch_indices_vec_scaled_up = ov::get_tensor_data_as<int64_t>(batch_indices);
+        ov::reference::roi_align<T, ov::reference::roi_policy::ROIAlignRotatedOpDefPolicy>(
+            input.data<const T>(),
+            rois.data<const T>(),
+            batch_indices_vec_scaled_up.data(),
+            out.data<T>(),
+            input.get_shape(),
+            rois.get_shape(),
+            batch_indices.get_shape(),
+            out.get_shape(),
+            pooled_h,
+            pooled_w,
+            sampling_ratio,
+            spatial_scale,
+            ov::op::v3::ROIAlign::PoolingMode::AVG,
+            ov::op::v9::ROIAlign::AlignedMode::ASYMMETRIC,
+            clockwise_mode);
+        return true;
+    }
+};
+}  // namespace helpers
+
 ROIAlignRotated::ROIAlignRotated(const Output<Node>& input,
                                  const Output<Node>& rois,
                                  const Output<Node>& batch_indices,
@@ -49,6 +90,43 @@ std::shared_ptr<Node> ROIAlignRotated::clone_with_new_inputs(const OutputVector&
                                              get_spatial_scale(),
                                              get_clockwise_mode());
 }
+
+bool ROIAlignRotated::evaluate(TensorVector& outputs, const TensorVector& inputs) const {
+    OPENVINO_ASSERT(outputs.size() == 1);
+    OPENVINO_ASSERT(inputs.size() == 3);
+
+    using namespace ov::element;
+    return IF_TYPE_OF_CONVERT_TENSORS(v14_ROIAlignRotated_evaluate,
+                                      this,
+                                      outputs,
+                                      inputs,
+                                      OV_PP_ET_LIST(bf16, f16, f32, f64),
+                                      helpers::Evaluate,
+                                      inputs[0].get_element_type(),
+                                      inputs[0],
+                                      inputs[1],
+                                      inputs[2],
+                                      outputs[0],
+                                      get_pooled_h(),
+                                      get_pooled_w(),
+                                      get_sampling_ratio(),
+                                      get_spatial_scale(),
+                                      get_clockwise_mode());
+    return true;
+}
+
+bool ROIAlignRotated::has_evaluate() const {
+    OV_OP_SCOPE(v14_ROIAlignRotated_has_evaluate);
+    switch (get_input_element_type(0)) {
+    case element::bf16:
+    case element::f16:
+    case element::f32:
+    case element::f64:
+        return true;
+    default:
+        return false;
+    }
+}
 }  // namespace v14
 }  // namespace op
 }  // namespace ov

src/core/tests/opset.cpp

@@ -74,8 +74,8 @@ INSTANTIATE_TEST_SUITE_P(opset,
                                          OpsetTestParams{ov::get_opset11, 177},
                                          OpsetTestParams{ov::get_opset12, 178},
                                          OpsetTestParams{ov::get_opset13, 186},
-                                         OpsetTestParams{ov::get_opset14, 188},
-                                         OpsetTestParams{ov::get_opset15, 5}),
+                                         OpsetTestParams{ov::get_opset14, 189},
+                                         OpsetTestParams{ov::get_opset15, 4}),
                          OpsetTestNameGenerator{});
 
 class MyOpOld : public ov::op::Op {

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/tests/functional/plugin/conformance/test_runner/op_conformance_runner/src/op_impl_check/single_op_graph.cpp

@@ -961,6 +961,19 @@ std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v9::ROIAlign>&
     return std::make_shared<ov::Model>(results, params, "ROIAlignGraph");
 }
 
+std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v14::ROIAlignRotated>& node) {
+    ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{{1, 1, 16, 16}})};
+    const auto coords = std::make_shared<ov::op::v0::Constant>(
+        ov::element::f32,
+        ov::Shape{1, static_cast<size_t>(node->get_rois_input_second_dim_size())},
+        std::vector<float>(node->get_rois_input_second_dim_size(), 0));
+    const auto roisIdx =
+        std::make_shared<ov::op::v0::Constant>(ov::element::i32, ov::Shape{1}, std::vector<int32_t>{0});
+    auto new_node = std::make_shared<ov::op::v14::ROIAlignRotated>(params.at(0), coords, roisIdx, 2, 2, 2, 1, true);
+    ov::ResultVector results{std::make_shared<ov::op::v0::Result>(new_node)};
+    return std::make_shared<ov::Model>(results, params, "ROIAlignRotatedGraph");
+}
+
 std::shared_ptr<ov::Model> generate(const std::shared_ptr<ov::op::v0::ROIPooling> &node) {
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{{1, 3, 8, 8}}),
                                std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::Shape{{1, 5}})};