IVGCVSW-2555 Add no-op implementation for Detection PostProcess

 * Added DetectionPostProcessQueueDescriptor to WorkloadData
 * Added CreateDetectionPostProcess function in WorkloadFactory.hpp
 * Added stub implementation of the CreateDetectionPostProcess
in workload factories
 * Added DetectionPostProcessLayer stub implementation
 * Added AddDetectionPostProcessLayer to Network
 * Added IsDetectionPostProcessSupported to LayerSupportBase

Change-Id: Ifc071b3b6b12877c997bdcc43d769c8f891d5c6c

8 files changed, 103 insertions, 0 deletions

diff --git a/src/armnn/InternalTypes.cpp b/src/armnn/InternalTypes.cpp
index 15f4aa07e2..e4a6ac82d5 100644
--- a/src/armnn/InternalTypes.cpp
+++ b/src/armnn/InternalTypes.cpp
@@ -24,6 +24,7 @@ char const* GetLayerTypeAsCString(LayerType type)
         case LayerType::Convolution2d: return "Convolution2d";
         case LayerType::Debug: return "Debug";
         case LayerType::DepthwiseConvolution2d: return "DepthwiseConvolution2d";
+        case LayerType::DetectionPostProcess: return "DetectionPostProcess";
         case LayerType::Division: return "Division";
         case LayerType::Equal: return "Equal";
         case LayerType::FakeQuantization: return "FakeQuantization";
diff --git a/src/armnn/InternalTypes.hpp b/src/armnn/InternalTypes.hpp
index 704efdf2b7..a61c7b8147 100644
--- a/src/armnn/InternalTypes.hpp
+++ b/src/armnn/InternalTypes.hpp
@@ -24,6 +24,7 @@ enum class LayerType
     Convolution2d,
     Debug,
     DepthwiseConvolution2d,
+    DetectionPostProcess,
     Division,
     Equal,
     FakeQuantization,
diff --git a/src/armnn/LayerSupport.cpp b/src/armnn/LayerSupport.cpp
index 2eaf780f91..484251ca97 100644
--- a/src/armnn/LayerSupport.cpp
+++ b/src/armnn/LayerSupport.cpp
@@ -190,6 +190,13 @@ bool IsDepthwiseConvolutionSupported(const BackendId& backend,
     FORWARD_LAYER_SUPPORT_FUNC(backend, IsDepthwiseConvolutionSupported, input, output, descriptor, weights, biases);
 }
 
+bool IsDetectionPostProcessSupported(const BackendId& backend,
+                                     const TensorInfo& input0,
+                                     const TensorInfo& input1,
+                                     const DetectionPostProcessDescriptor& descriptor,
+                                     char* reasonIfUnsupported,
+                                     size_t reasonIfUnsupportedMaxLength);
+
 bool IsDivisionSupported(const BackendId& backend,
                          const TensorInfo& input0,
                          const TensorInfo& input1,
diff --git a/src/armnn/LayersFwd.hpp b/src/armnn/LayersFwd.hpp
index 27806c5752..497b517f28 100644
--- a/src/armnn/LayersFwd.hpp
+++ b/src/armnn/LayersFwd.hpp
@@ -16,6 +16,7 @@
 #include "layers/Convolution2dLayer.hpp"
 #include "layers/DebugLayer.hpp"
 #include "layers/DepthwiseConvolution2dLayer.hpp"
+#include "layers/DetectionPostProcessLayer.hpp"
 #include "layers/DivisionLayer.hpp"
 #include "layers/EqualLayer.hpp"
 #include "layers/FakeQuantizationLayer.hpp"
@@ -84,6 +85,7 @@ DECLARE_LAYER(ConvertFp32ToFp16)
 DECLARE_LAYER(Convolution2d)
 DECLARE_LAYER(Debug)
 DECLARE_LAYER(DepthwiseConvolution2d)
+DECLARE_LAYER(DetectionPostProcess)
 DECLARE_LAYER(Division)
 DECLARE_LAYER(Equal)
 DECLARE_LAYER(FakeQuantization)
diff --git a/src/armnn/Network.cpp b/src/armnn/Network.cpp
index f9ebad2b08..662a9ccd3c 100644
--- a/src/armnn/Network.cpp
+++ b/src/armnn/Network.cpp
@@ -594,6 +594,12 @@ IConnectableLayer* Network::AddDepthwiseConvolution2dLayer(
     return AddDepthwiseConvolution2dLayerImpl(convolution2dDescriptor, weights, &biases, name);
 }
 
+IConnectableLayer* Network::AddDetectionPostProcessLayer(const armnn::DetectionPostProcessDescriptor& descriptor,
+                                                         const char* name)
+{
+    return m_Graph->AddLayer<DetectionPostProcessLayer>(descriptor, name);
+}
+
 IConnectableLayer* Network::AddPermuteLayer(const PermuteDescriptor& permuteDescriptor,
                                             const char* name)
 {
diff --git a/src/armnn/Network.hpp b/src/armnn/Network.hpp
index 7690fafac0..4239ac5ba4 100644
--- a/src/armnn/Network.hpp
+++ b/src/armnn/Network.hpp
@@ -57,6 +57,10 @@ public:
         const ConstTensor&                      biases,
         const char*                             name = nullptr) override;
 
+    IConnectableLayer* AddDetectionPostProcessLayer(
+        const DetectionPostProcessDescriptor& descriptor,
+        const char* name = nullptr) override;
+
     IConnectableLayer* AddFullyConnectedLayer(const FullyConnectedDescriptor& fullyConnectedDescriptor,
         const ConstTensor& weights,
         const char* name = nullptr) override;
diff --git a/src/armnn/layers/DetectionPostProcessLayer.cpp b/src/armnn/layers/DetectionPostProcessLayer.cpp
new file mode 100644
index 0000000000..99aaac7b9f
--- /dev/null
+++ b/src/armnn/layers/DetectionPostProcessLayer.cpp
@@ -0,0 +1,39 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "DetectionPostProcessLayer.hpp"
+
+#include "LayerCloneBase.hpp"
+
+#include <armnn/TypesUtils.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+namespace armnn
+{
+
+DetectionPostProcessLayer::DetectionPostProcessLayer(const DetectionPostProcessDescriptor& param, const char* name)
+    : LayerWithParameters(2, 4, LayerType::DetectionPostProcess, param, name)
+{
+}
+
+std::unique_ptr<IWorkload> DetectionPostProcessLayer::CreateWorkload(const armnn::Graph& graph,
+                                                                     const armnn::IWorkloadFactory& factory) const
+{
+    DetectionPostProcessQueueDescriptor descriptor;
+    return factory.CreateDetectionPostProcess(descriptor, PrepInfoAndDesc(descriptor, graph));
+}
+
+DetectionPostProcessLayer* DetectionPostProcessLayer::Clone(Graph& graph) const
+{
+    return CloneBase<DetectionPostProcessLayer>(graph, m_Param, GetName());
+}
+
+void DetectionPostProcessLayer::ValidateTensorShapesFromInputs()
+{
+    VerifyLayerConnections(2, CHECK_LOCATION());
+}
+
+} // namespace armnn
diff --git a/src/armnn/layers/DetectionPostProcessLayer.hpp b/src/armnn/layers/DetectionPostProcessLayer.hpp
new file mode 100644
index 0000000000..b5a1cf17fb
--- /dev/null
+++ b/src/armnn/layers/DetectionPostProcessLayer.hpp
@@ -0,0 +1,43 @@
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerWithParameters.hpp"
+
+namespace armnn
+{
+
+/// This layer represents a detection postprocess operator.
+class DetectionPostProcessLayer : public LayerWithParameters<DetectionPostProcessDescriptor>
+{
+public:
+    /// Makes a workload for the DetectionPostProcess type.
+    /// @param [in] graph The graph where this layer can be found.
+    /// @param [in] factory The workload factory which will create the workload.
+    /// @return A pointer to the created workload, or nullptr if not created.
+    virtual std::unique_ptr<IWorkload> CreateWorkload(const Graph& graph,
+                                                      const IWorkloadFactory& factory) const override;
+
+    /// Creates a dynamically-allocated copy of this layer.
+    /// @param [in] graph The graph into which this layer is being cloned.
+    DetectionPostProcessLayer* Clone(Graph& graph) const override;
+
+    /// Check if the input tensor shape(s)
+    /// will lead to a valid configuration of @ref DetectionPostProcessLayer.
+    void ValidateTensorShapesFromInputs() override;
+
+protected:
+    /// Constructor to create a DetectionPostProcessLayer.
+    /// @param [in] param DetectionPostProcessDescriptor to configure the detection postprocess.
+    /// @param [in] name Optional name for the layer.
+    DetectionPostProcessLayer(const DetectionPostProcessDescriptor& param, const char* name);
+
+    /// Default destructor
+    ~DetectionPostProcessLayer() = default;
+};
+
+} // namespace armnn
+