[ONNX] Extend ONNX Frontend with BlackmanWindow, HammingWindow and HannWindow operators

src/frontends/onnx/frontend/src/op/blackmanwindow.cpp

@@ -0,0 +1,97 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#include "op/blackmanwindow.hpp"
+
+#include <memory>
+
+#include "utils/common.hpp"
+#include "default_opset.hpp"
+
+namespace ngraph {
+namespace onnx_import {
+namespace op {
+namespace set_1 {
+OutputVector blackmanwindow(const Node& node) {
+    const auto size = node.get_ng_inputs().at(0);
+    const auto output_datatype = node.get_attribute_value<int64_t>("output_datatype", 1);
+    const bool periodic = node.get_attribute_value<int64_t>("periodic", 1);
+
+    const int64_t a_0 = 0.42, a_1 = -0.5, a_2 = 0.08;
+    const ov::PartialShape shape = size.get_partial_shape();
+    const std::vector<size_t> axis_lengths = shape.to_shape();
+
+    element::Type tensor_type;
+    switch (output_datatype) {
+        case 1:
+            tensor_type = element::f32;
+            break;
+        case 2:
+            tensor_type = element::u8;
+            break;
+        case 3:
+            tensor_type = element::i8;
+            break;
+        case 4:
+            tensor_type = element::u16;
+            break;
+        case 5:
+            tensor_type = element::i16;
+            break;
+        case 6:
+            tensor_type = element::i32;
+            break;
+        case 7:
+            tensor_type = element::i64;
+            break;
+        case 10:
+            tensor_type = element::f16;
+            break;
+        case 11:
+            tensor_type = element::f64;
+            break;
+        case 12:
+            tensor_type = element::u32;
+            break;
+        case 13:
+            tensor_type = element::u64;
+            break;
+        case 16:
+            tensor_type = element::bf16;
+            break;
+        default:
+            throw std::runtime_error("Unsupported output data type.");
+    }
+
+    if (periodic) {
+        const auto range = std::make_shared<default_opset::Range>(tensor_type, size, 0, 1);
+        const auto pi = default_opset::Constant::create(tensor_type, ov::Shape(), {static_cast<float>(M_PI)});
+        const auto factor_1 = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 2), size));
+        const auto factor_2 = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 4), size));
+        const auto cos_1 = std::make_shared<default_opset::Cos>(factor_1);
+        const auto cos_2 = std::make_shared<default_opset::Cos>(factor_2);
+        const auto scaled_cos_1 = std::make_shared<default_opset::Multiply>(cos_1, a_1);
+        const auto scaled_cos_2 = std::make_shared<default_opset::Multiply>(cos_2, a_2);
+        const auto y_values = std::make_shared<default_opset::Add>(std::make_shared<default_opset::Add>(a_0, scaled_cos_1), scaled_cos_2);
+        const auto output = std::make_shared<default_opset::Constant>(tensor_type, ov::Shape(axis_lengths), y_values);
+
+        return {output};
+    } else {
+        const auto range = std::make_shared<default_opset::Range>(tensor_type, size, 0, 1);
+        const auto pi = default_opset::Constant::create(tensor_type, ov::Shape(), {static_cast<float>(M_PI)});
+        const auto factor_1 = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 2), std::make_shared<default_opset::Subtract>(size, 1)));
+        const auto factor_2 = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 4), std::make_shared<default_opset::Subtract>(size, 1)));
+        const auto cos_1 = std::make_shared<default_opset::Cos>(factor_1);
+        const auto cos_2 = std::make_shared<default_opset::Cos>(factor_2);
+        const auto scaled_cos_1 = std::make_shared<default_opset::Multiply>(cos_1, a_1);
+        const auto scaled_cos_2 = std::make_shared<default_opset::Multiply>(cos_2, a_2);
+        const auto y_values = std::make_shared<default_opset::Add>(std::make_shared<default_opset::Add>(a_0, scaled_cos_1), scaled_cos_2);
+        const auto output = std::make_shared<default_opset::Constant>(tensor_type, ov::Shape(axis_lengths), y_values);
+
+        return {output};
+    }
+}
+}  // namespace set_1
+}  // namespace op
+}  // namespace onnx_import
+}  // namespace ngraph

src/frontends/onnx/frontend/src/op/blackmanwindow.hpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ngraph/node.hpp"
+#include "onnx_import/core/node.hpp"
+
+namespace ngraph {
+namespace onnx_import {
+namespace op {
+namespace set_1 {
+
+OutputVector blackmanwindow(const Node& node);
+
+}  // namespace set_1
+}  // namespace op
+}  // namespace onnx_import
+}  // namespace ngraph

src/frontends/onnx/frontend/src/op/hammingwindow.cpp

@@ -0,0 +1,93 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#include "op/hammingwindow.hpp"
+
+#include <memory>
+
+#include "utils/common.hpp"
+#include "default_opset.hpp"
+
+namespace ngraph {
+namespace onnx_import {
+namespace op {
+namespace set_1 {
+OutputVector hammingwindow(const Node& node) {
+    const auto size = node.get_ng_inputs().at(0);
+    const auto output_datatype = node.get_attribute_value<int64_t>("output_datatype", 1);
+    const bool periodic = node.get_attribute_value<int64_t>("periodic", 1);
+
+    const float a_0 = 25.0 / 46.0;
+    const float a_1 = 1.0 - a_0;
+
+    const ov::PartialShape shape = size.get_partial_shape();
+    const std::vector<size_t> axis_lengths = shape.to_shape();
+
+    element::Type tensor_type;
+    switch (output_datatype) {
+        case 1:
+            tensor_type = element::f32;
+            break;
+        case 2:
+            tensor_type = element::u8;
+            break;
+        case 3:
+            tensor_type = element::i8;
+            break;
+        case 4:
+            tensor_type = element::u16;
+            break;
+        case 5:
+            tensor_type = element::i16;
+            break;
+        case 6:
+            tensor_type = element::i32;
+            break;
+        case 7:
+            tensor_type = element::i64;
+            break;
+        case 10:
+            tensor_type = element::f16;
+            break;
+        case 11:
+            tensor_type = element::f64;
+            break;
+        case 12:
+            tensor_type = element::u32;
+            break;
+        case 13:
+            tensor_type = element::u64;
+            break;
+        case 16:
+            tensor_type = element::bf16;
+            break;
+        default:
+            throw std::runtime_error("Unsupported output data type.");
+    }
+
+    if (periodic) {
+        const auto range = std::make_shared<default_opset::Range>(tensor_type, size, 0, 1);
+        const auto pi = default_opset::Constant::create(tensor_type, ov::Shape(), {static_cast<float>(M_PI)});
+        const auto factor = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 2), size));
+        const auto cos = std::make_shared<default_opset::Cos>(factor);
+        const auto scaled_cos = std::make_shared<default_opset::Multiply>(cos, a_1);
+        const auto y_values = std::make_shared<default_opset::Subtract>(a_0, scaled_cos);
+        const auto output = std::make_shared<default_opset::Constant>(tensor_type, ov::Shape(axis_lengths), y_values);
+
+        return {output};
+    } else {
+        const auto range = std::make_shared<default_opset::Range>(tensor_type, size, 0, 1);
+        const auto pi = default_opset::Constant::create(tensor_type, ov::Shape(), {static_cast<float>(M_PI)});
+        const auto factor = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 2), std::make_shared<default_opset::Subtract>(size, 1)));
+        const auto cos = std::make_shared<default_opset::Cos>(factor);
+        const auto scaled_cos = std::make_shared<default_opset::Multiply>(cos, a_1);
+        const auto y_values = std::make_shared<default_opset::Subtract>(a_0, scaled_cos);
+        const auto output = std::make_shared<default_opset::Constant>(tensor_type, ov::Shape(axis_lengths), y_values);
+
+        return {output};
+    }
+}
+}  // namespace set_1
+}  // namespace op
+}  // namespace onnx_import
+}  // namespace ngraph

src/frontends/onnx/frontend/src/op/hammingwindow.hpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ngraph/node.hpp"
+#include "onnx_import/core/node.hpp"
+
+namespace ngraph {
+namespace onnx_import {
+namespace op {
+namespace set_1 {
+
+OutputVector hammingwindow(const Node& node);
+
+}  // namespace set_1
+}  // namespace op
+}  // namespace onnx_import
+}  // namespace ngraph

src/frontends/onnx/frontend/src/op/hannwindow.cpp

@@ -0,0 +1,93 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#include "op/hannwindow.hpp"
+
+#include <memory>
+
+#include "utils/common.hpp"
+#include "default_opset.hpp"
+
+namespace ngraph {
+namespace onnx_import {
+namespace op {
+namespace set_1 {
+OutputVector hannwindow(const Node& node) {
+    const auto size = node.get_ng_inputs().at(0);
+    const auto output_datatype = node.get_attribute_value<int64_t>("output_datatype", 1);
+    const bool periodic = node.get_attribute_value<int64_t>("periodic", 1);
+
+    const float a_0 = 0.5;
+    const float a_1 = 0.5;
+
+    const ov::PartialShape shape = size.get_partial_shape();
+    const std::vector<size_t> axis_lengths = shape.to_shape();
+
+    element::Type tensor_type;
+    switch (output_datatype) {
+        case 1:
+            tensor_type = element::f32;
+            break;
+        case 2:
+            tensor_type = element::u8;
+            break;
+        case 3:
+            tensor_type = element::i8;
+            break;
+        case 4:
+            tensor_type = element::u16;
+            break;
+        case 5:
+            tensor_type = element::i16;
+            break;
+        case 6:
+            tensor_type = element::i32;
+            break;
+        case 7:
+            tensor_type = element::i64;
+            break;
+        case 10:
+            tensor_type = element::f16;
+            break;
+        case 11:
+            tensor_type = element::f64;
+            break;
+        case 12:
+            tensor_type = element::u32;
+            break;
+        case 13:
+            tensor_type = element::u64;
+            break;
+        case 16:
+            tensor_type = element::bf16;
+            break;
+        default:
+            throw std::runtime_error("Unsupported output data type.");
+    }
+
+    if (periodic) {
+        const auto range = std::make_shared<default_opset::Range>(tensor_type, size, 0, 1);
+        const auto pi = default_opset::Constant::create(tensor_type, ov::Shape(), {static_cast<float>(M_PI)});
+        const auto factor = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 2), size));
+        const auto cos = std::make_shared<default_opset::Cos>(factor);
+        const auto scaled_cos = std::make_shared<default_opset::Multiply>(cos, a_1);
+        const auto y_values = std::make_shared<default_opset::Subtract>(a_0, scaled_cos);
+        const auto output = std::make_shared<default_opset::Constant>(tensor_type, ov::Shape(axis_lengths), y_values);
+
+        return {output};
+    } else {
+        const auto range = std::make_shared<default_opset::Range>(tensor_type, size, 0, 1);
+        const auto pi = default_opset::Constant::create(tensor_type, ov::Shape(), {static_cast<float>(M_PI)});
+        const auto factor = std::make_shared<default_opset::Multiply>(range, std::make_shared<default_opset::Divide>(std::make_shared<default_opset::Multiply>(pi, 2), std::make_shared<default_opset::Subtract>(size, 1)));
+        const auto cos = std::make_shared<default_opset::Cos>(factor);
+        const auto scaled_cos = std::make_shared<default_opset::Multiply>(cos, a_1);
+        const auto y_values = std::make_shared<default_opset::Subtract>(a_0, scaled_cos);
+        const auto output = std::make_shared<default_opset::Constant>(tensor_type, ov::Shape(axis_lengths), y_values);
+
+        return {output};
+    }
+}
+}  // namespace set_1
+}  // namespace op
+}  // namespace onnx_import
+}  // namespace ngraph

src/frontends/onnx/frontend/src/op/hannwindow.hpp

@@ -0,0 +1,19 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ngraph/node.hpp"
+#include "onnx_import/core/node.hpp"
+
+namespace ngraph {
+namespace onnx_import {
+namespace op {
+namespace set_1 {
+
+OutputVector hannwindow(const Node& node);
+
+}  // namespace set_1
+}  // namespace op
+}  // namespace onnx_import
+}  // namespace ngraph

src/frontends/onnx/frontend/src/ops_bridge.cpp

@@ -29,6 +29,7 @@
 #include "op/average_pool.hpp"
 #include "op/batch_norm.hpp"
 #include "op/bitshift.hpp"
+#include "op/blackmanwindow.hpp"
 #include "op/cast.hpp"
 #include "op/cast_like.hpp"
 #include "op/ceil.hpp"
@@ -75,6 +76,8 @@
 #include "op/greater.hpp"
 #include "op/grid_sample.hpp"
 #include "op/gru.hpp"
+#include "op/hammingwindow.hpp"
+#include "op/hannwindow.hpp"
 #include "op/hard_sigmoid.hpp"
 #include "op/hard_swish.hpp"
 #include "op/hardmax.hpp"
@@ -343,6 +346,7 @@ OperatorsBridge::OperatorsBridge() {
     REGISTER_OPERATOR("BatchNormalization", 1, batch_norm);
     REGISTER_OPERATOR("BatchNormalization", 7, batch_norm);
     REGISTER_OPERATOR("BitShift", 1, bitshift);
+    REGISTER_OPERATOR("BlackManWindow", 1, blackmanwindow);
     REGISTER_OPERATOR("Cast", 1, cast);
     REGISTER_OPERATOR("CastLike", 1, cast_like);
     REGISTER_OPERATOR("Ceil", 1, ceil);
@@ -390,6 +394,8 @@ OperatorsBridge::OperatorsBridge() {
     REGISTER_OPERATOR("Greater", 1, greater);
     REGISTER_OPERATOR("GridSample", 1, grid_sample);
     REGISTER_OPERATOR("GRU", 1, gru);
+    REGISTER_OPERATOR("HannWindow", 1, hannwindow);
+    REGISTER_OPERATOR("HammingWindow", 1, hammingwindow);
     REGISTER_OPERATOR("Hardmax", 1, hardmax);
     REGISTER_OPERATOR("Hardmax", 13, hardmax);
     REGISTER_OPERATOR("HardSigmoid", 1, hard_sigmoid);