diff --git a/source/use_case/object_detection/include/DetectorPostProcessing.hpp b/source/use_case/object_detection/include/DetectorPostProcessing.hpp
index cdb14f5..b3ddb2c 100644
--- a/source/use_case/object_detection/include/DetectorPostProcessing.hpp
+++ b/source/use_case/object_detection/include/DetectorPostProcessing.hpp
@@ -21,11 +21,13 @@
 #include "ImageUtils.hpp"
 #include "DetectionResult.hpp"
 #include "YoloFastestModel.hpp"
+#include "BaseProcessing.hpp"
 
 #include <forward_list>
 
 namespace arm {
 namespace app {
+
 namespace object_detection {
 
     struct Branch {
@@ -46,42 +48,55 @@
         int topN;
     };
 
+} /* namespace object_detection */
+
     /**
-     * @brief   Helper class to manage tensor post-processing for "object_detection"
-     *          output.
+     * @brief   Post-processing class for Object Detection use case.
+     *          Implements methods declared by BasePostProcess and anything else needed
+     *          to populate result vector.
      */
-    class DetectorPostprocessing {
+    class DetectorPostProcess : public BasePostProcess {
     public:
         /**
-         * @brief       Constructor.
-         * @param[in]   threshold     Post-processing threshold.
-         * @param[in]   nms           Non-maximum Suppression threshold.
-         * @param[in]   numClasses    Number of classes.
-         * @param[in]   topN          Top N for each class.
+         * @brief        Constructor.
+         * @param[in]    outputTensor0   Pointer to the TFLite Micro output Tensor at index 0.
+         * @param[in]    outputTensor1   Pointer to the TFLite Micro output Tensor at index 1.
+         * @param[out]   results         Vector of detected results.
+         * @param[in]    inputImgRows    Number of rows in the input image.
+         * @param[in]    inputImgCols    Number of columns in the input image.
+         * @param[in]    threshold       Post-processing threshold.
+         * @param[in]    nms             Non-maximum Suppression threshold.
+         * @param[in]    numClasses      Number of classes.
+         * @param[in]    topN            Top N for each class.
          **/
-        explicit DetectorPostprocessing(float threshold = 0.5f,
-                                        float nms = 0.45f,
-                                        int numClasses = 1,
-                                        int topN = 0);
+        explicit DetectorPostProcess(TfLiteTensor* outputTensor0,
+                                     TfLiteTensor* outputTensor1,
+                                     std::vector<object_detection::DetectionResult>& results,
+                                     int inputImgRows,
+                                     int inputImgCols,
+                                     float threshold = 0.5f,
+                                     float nms = 0.45f,
+                                     int numClasses = 1,
+                                     int topN = 0);
 
         /**
-         * @brief       Post processing part of YOLO object detection CNN.
-         * @param[in]   imgRows      Number of rows in the input image.
-         * @param[in]   imgCols      Number of columns in the input image.
-         * @param[in]   modelOutput  Output tensors after CNN invoked.
-         * @param[out]  resultsOut   Vector of detected results.
+         * @brief    Should perform YOLO post-processing of the result of inference then
+         *           populate Detection result data for any later use.
+         * @return   true if successful, false otherwise.
          **/
-        void RunPostProcessing(uint32_t imgRows,
-                               uint32_t imgCols,
-                               TfLiteTensor* modelOutput0,
-                               TfLiteTensor* modelOutput1,
-                               std::vector<DetectionResult>& resultsOut);
+        bool DoPostProcess() override;
 
     private:
-        float m_threshold;  /* Post-processing threshold */
-        float m_nms;        /* NMS threshold */
-        int   m_numClasses; /* Number of classes */
-        int   m_topN;       /* TopN */
+        TfLiteTensor* m_outputTensor0;     /* Output tensor index 0 */
+        TfLiteTensor* m_outputTensor1;     /* Output tensor index 1 */
+        std::vector<object_detection::DetectionResult>& m_results;  /* Single inference results. */
+        int m_inputImgRows;                /* Number of rows for model input. */
+        int m_inputImgCols;                /* Number of cols for model input. */
+        float m_threshold;                 /* Post-processing threshold. */
+        float m_nms;                       /* NMS threshold. */
+        int   m_numClasses;                /* Number of classes. */
+        int   m_topN;                      /* TopN. */
+        object_detection::Network m_net;   /* YOLO network object. */
 
         /**
          * @brief       Insert the given Detection in the list.
@@ -98,32 +113,13 @@
          * @param[in]    threshold     Detections threshold.
          * @param[out]   detections    Detection boxes.
          **/
-        void GetNetworkBoxes(Network& net,
+        void GetNetworkBoxes(object_detection::Network& net,
                              int imageWidth,
                              int imageHeight,
                              float threshold,
                              std::forward_list<image::Detection>& detections);
-
-        /**
-         * @brief       Draw on the given image a bounding box starting at (boxX, boxY).
-         * @param[in/out]   imgIn    Image.
-         * @param[in]       imWidth    Image width.
-         * @param[in]       imHeight   Image height.
-         * @param[in]       boxX       Axis X starting point.
-         * @param[in]       boxY       Axis Y starting point.
-         * @param[in]       boxWidth   Box width.
-         * @param[in]       boxHeight  Box height.
-         **/
-        void DrawBoxOnImage(uint8_t* imgIn,
-                            int imWidth,
-                            int imHeight,
-                            int boxX,
-                            int boxY,
-                            int boxWidth,
-                            int boxHeight);
     };
 
-} /* namespace object_detection */
 } /* namespace app */
 } /* namespace arm */
 
diff --git a/source/use_case/object_detection/include/DetectorPreProcessing.hpp b/source/use_case/object_detection/include/DetectorPreProcessing.hpp
new file mode 100644
index 0000000..4936048
--- /dev/null
+++ b/source/use_case/object_detection/include/DetectorPreProcessing.hpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2022 Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef DETECTOR_PRE_PROCESSING_HPP
+#define DETECTOR_PRE_PROCESSING_HPP
+
+#include "BaseProcessing.hpp"
+#include "Classifier.hpp"
+
+namespace arm {
+namespace app {
+
+    /**
+     * @brief   Pre-processing class for Object detection use case.
+     *          Implements methods declared by BasePreProcess and anything else needed
+     *          to populate input tensors ready for inference.
+     */
+    class DetectorPreProcess : public BasePreProcess {
+
+    public:
+        /**
+         * @brief       Constructor
+         * @param[in]   inputTensor     Pointer to the TFLite Micro input Tensor.
+         * @param[in]   rgb2Gray        Convert image from 3 channel RGB to 1 channel grayscale.
+         * @param[in]   convertToInt8   Convert the image from uint8 to int8 range.
+         **/
+        explicit DetectorPreProcess(TfLiteTensor* inputTensor, bool rgb2Gray, bool convertToInt8);
+
+        /**
+         * @brief       Should perform pre-processing of 'raw' input image data and load it into
+         *              TFLite Micro input tensor ready for inference
+         * @param[in]   input      Pointer to the data that pre-processing will work on.
+         * @param[in]   inputSize  Size of the input data.
+         * @return      true if successful, false otherwise.
+         **/
+        bool DoPreProcess(const void* input, size_t inputSize) override;
+
+    private:
+        TfLiteTensor* m_inputTensor;
+        bool m_rgb2Gray;
+        bool m_convertToInt8;
+    };
+
+} /* namespace app */
+} /* namespace arm */
+
+#endif /* DETECTOR_PRE_PROCESSING_HPP */
\ No newline at end of file
diff --git a/source/use_case/object_detection/src/DetectorPostProcessing.cc b/source/use_case/object_detection/src/DetectorPostProcessing.cc
index a890c9e..fb1606a 100644
--- a/source/use_case/object_detection/src/DetectorPostProcessing.cc
+++ b/source/use_case/object_detection/src/DetectorPostProcessing.cc
@@ -21,64 +21,73 @@
 
 namespace arm {
 namespace app {
-namespace object_detection {
 
-DetectorPostprocessing::DetectorPostprocessing(
-    const float threshold,
-    const float nms,
-    int numClasses,
-    int topN)
-    :   m_threshold(threshold),
-        m_nms(nms),
-        m_numClasses(numClasses),
-        m_topN(topN)
-{}
-
-void DetectorPostprocessing::RunPostProcessing(
-    uint32_t imgRows,
-    uint32_t imgCols,
-    TfLiteTensor* modelOutput0,
-    TfLiteTensor* modelOutput1,
-    std::vector<DetectionResult>& resultsOut)
+    DetectorPostProcess::DetectorPostProcess(
+        TfLiteTensor* modelOutput0,
+        TfLiteTensor* modelOutput1,
+        std::vector<object_detection::DetectionResult>& results,
+        int inputImgRows,
+        int inputImgCols,
+        const float threshold,
+        const float nms,
+        int numClasses,
+        int topN)
+        :   m_outputTensor0{modelOutput0},
+            m_outputTensor1{modelOutput1},
+            m_results{results},
+            m_inputImgRows{inputImgRows},
+            m_inputImgCols{inputImgCols},
+            m_threshold(threshold),
+            m_nms(nms),
+            m_numClasses(numClasses),
+            m_topN(topN)
 {
-    /* init postprocessing */
-    Network net {
-        .inputWidth = static_cast<int>(imgCols),
-        .inputHeight = static_cast<int>(imgRows),
-        .numClasses = m_numClasses,
+    /* Init PostProcessing */
+    this->m_net =
+    object_detection::Network {
+        .inputWidth = inputImgCols,
+        .inputHeight = inputImgRows,
+        .numClasses = numClasses,
         .branches = {
-            Branch {
-                .resolution = static_cast<int>(imgCols/32),
-                .numBox = 3,
-                .anchor = anchor1,
-                .modelOutput = modelOutput0->data.int8,
-                .scale = ((TfLiteAffineQuantization*)(modelOutput0->quantization.params))->scale->data[0],
-                .zeroPoint = ((TfLiteAffineQuantization*)(modelOutput0->quantization.params))->zero_point->data[0],
-                .size = modelOutput0->bytes
+            object_detection::Branch {
+                        .resolution = inputImgCols/32,
+                        .numBox = 3,
+                        .anchor = anchor1,
+                        .modelOutput = this->m_outputTensor0->data.int8,
+                        .scale = (static_cast<TfLiteAffineQuantization*>(
+                                this->m_outputTensor0->quantization.params))->scale->data[0],
+                        .zeroPoint = (static_cast<TfLiteAffineQuantization*>(
+                                this->m_outputTensor0->quantization.params))->zero_point->data[0],
+                        .size = this->m_outputTensor0->bytes
             },
-            Branch {
-                .resolution = static_cast<int>(imgCols/16),
-                .numBox = 3,
-                .anchor = anchor2,
-                .modelOutput = modelOutput1->data.int8,
-                .scale = ((TfLiteAffineQuantization*)(modelOutput1->quantization.params))->scale->data[0],
-                .zeroPoint = ((TfLiteAffineQuantization*)(modelOutput1->quantization.params))->zero_point->data[0],
-                .size = modelOutput1->bytes
+            object_detection::Branch {
+                    .resolution = inputImgCols/16,
+                    .numBox = 3,
+                    .anchor = anchor2,
+                    .modelOutput = this->m_outputTensor1->data.int8,
+                    .scale = (static_cast<TfLiteAffineQuantization*>(
+                            this->m_outputTensor1->quantization.params))->scale->data[0],
+                    .zeroPoint = (static_cast<TfLiteAffineQuantization*>(
+                            this->m_outputTensor1->quantization.params))->zero_point->data[0],
+                    .size = this->m_outputTensor1->bytes
             }
         },
         .topN = m_topN
     };
     /* End init */
+}
 
+bool DetectorPostProcess::DoPostProcess()
+{
     /* Start postprocessing */
     int originalImageWidth = originalImageSize;
     int originalImageHeight = originalImageSize;
 
     std::forward_list<image::Detection> detections;
-    GetNetworkBoxes(net, originalImageWidth, originalImageHeight, m_threshold, detections);
+    GetNetworkBoxes(this->m_net, originalImageWidth, originalImageHeight, m_threshold, detections);
 
     /* Do nms */
-    CalculateNMS(detections, net.numClasses, m_nms);
+    CalculateNMS(detections, this->m_net.numClasses, m_nms);
 
     for (auto& it: detections) {
         float xMin = it.bbox.x - it.bbox.w / 2.0f;
@@ -104,24 +113,24 @@
         float boxWidth = xMax - xMin;
         float boxHeight = yMax - yMin;
 
-        for (int j = 0; j < net.numClasses; ++j) {
+        for (int j = 0; j < this->m_net.numClasses; ++j) {
             if (it.prob[j] > 0) {
 
-                DetectionResult tmpResult = {};
+                object_detection::DetectionResult tmpResult = {};
                 tmpResult.m_normalisedVal = it.prob[j];
                 tmpResult.m_x0 = boxX;
                 tmpResult.m_y0 = boxY;
                 tmpResult.m_w = boxWidth;
                 tmpResult.m_h = boxHeight;
 
-                resultsOut.push_back(tmpResult);
+                this->m_results.push_back(tmpResult);
             }
         }
     }
+    return true;
 }
 
-
-void DetectorPostprocessing::InsertTopNDetections(std::forward_list<image::Detection>& detections, image::Detection& det)
+void DetectorPostProcess::InsertTopNDetections(std::forward_list<image::Detection>& detections, image::Detection& det)
 {
     std::forward_list<image::Detection>::iterator it;
     std::forward_list<image::Detection>::iterator last_it;
@@ -136,7 +145,12 @@
     }
 }
 
-void DetectorPostprocessing::GetNetworkBoxes(Network& net, int imageWidth, int imageHeight, float threshold, std::forward_list<image::Detection>& detections)
+void DetectorPostProcess::GetNetworkBoxes(
+        object_detection::Network& net,
+        int imageWidth,
+        int imageHeight,
+        float threshold,
+        std::forward_list<image::Detection>& detections)
 {
     int numClasses = net.numClasses;
     int num = 0;
@@ -169,10 +183,14 @@
                         int bbox_h_offset = bbox_x_offset + 3;
                         int bbox_scores_offset = bbox_x_offset + 5;
 
-                        det.bbox.x = (static_cast<float>(net.branches[i].modelOutput[bbox_x_offset]) - net.branches[i].zeroPoint) * net.branches[i].scale;
-                        det.bbox.y = (static_cast<float>(net.branches[i].modelOutput[bbox_y_offset]) - net.branches[i].zeroPoint) * net.branches[i].scale;
-                        det.bbox.w = (static_cast<float>(net.branches[i].modelOutput[bbox_w_offset]) - net.branches[i].zeroPoint) * net.branches[i].scale;
-                        det.bbox.h = (static_cast<float>(net.branches[i].modelOutput[bbox_h_offset]) - net.branches[i].zeroPoint) * net.branches[i].scale;
+                        det.bbox.x = (static_cast<float>(net.branches[i].modelOutput[bbox_x_offset])
+                                - net.branches[i].zeroPoint) * net.branches[i].scale;
+                        det.bbox.y = (static_cast<float>(net.branches[i].modelOutput[bbox_y_offset])
+                                - net.branches[i].zeroPoint) * net.branches[i].scale;
+                        det.bbox.w = (static_cast<float>(net.branches[i].modelOutput[bbox_w_offset])
+                                - net.branches[i].zeroPoint) * net.branches[i].scale;
+                        det.bbox.h = (static_cast<float>(net.branches[i].modelOutput[bbox_h_offset])
+                                - net.branches[i].zeroPoint) * net.branches[i].scale;
 
                         float bbox_x, bbox_y;
 
@@ -218,6 +236,5 @@
         num -=1;
 }
 
-} /* namespace object_detection */
 } /* namespace app */
 } /* namespace arm */
diff --git a/source/use_case/object_detection/src/DetectorPreProcessing.cc b/source/use_case/object_detection/src/DetectorPreProcessing.cc
new file mode 100644
index 0000000..7212046
--- /dev/null
+++ b/source/use_case/object_detection/src/DetectorPreProcessing.cc
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2022 Arm Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "DetectorPreProcessing.hpp"
+#include "ImageUtils.hpp"
+#include "log_macros.h"
+
+namespace arm {
+namespace app {
+
+    DetectorPreProcess::DetectorPreProcess(TfLiteTensor* inputTensor, bool rgb2Gray, bool convertToInt8)
+    :   m_inputTensor{inputTensor},
+        m_rgb2Gray{rgb2Gray},
+        m_convertToInt8{convertToInt8}
+    {}
+
+    bool DetectorPreProcess::DoPreProcess(const void* data, size_t inputSize) {
+        if (data == nullptr) {
+            printf_err("Data pointer is null");
+        }
+
+        auto input = static_cast<const uint8_t*>(data);
+
+        if (this->m_rgb2Gray) {
+            image::RgbToGrayscale(input, this->m_inputTensor->data.uint8, this->m_inputTensor->bytes);
+        } else {
+            std::memcpy(this->m_inputTensor->data.data, input, inputSize);
+        }
+        debug("Input tensor populated \n");
+
+        if (this->m_convertToInt8) {
+            image::ConvertImgToInt8(this->m_inputTensor->data.data, this->m_inputTensor->bytes);
+        }
+
+        return true;
+    }
+
+} /* namespace app */
+} /* namespace arm */
\ No newline at end of file
diff --git a/source/use_case/object_detection/src/MainLoop.cc b/source/use_case/object_detection/src/MainLoop.cc
index acfc195..4291164 100644
--- a/source/use_case/object_detection/src/MainLoop.cc
+++ b/source/use_case/object_detection/src/MainLoop.cc
@@ -19,7 +19,6 @@
 #include "YoloFastestModel.hpp"       /* Model class for running inference. */
 #include "UseCaseHandler.hpp"         /* Handlers for different user options. */
 #include "UseCaseCommonUtils.hpp"     /* Utils functions. */
-#include "DetectorPostProcessing.hpp" /* Post-processing class. */
 #include "log_macros.h"
 
 static void DisplayDetectionMenu()
@@ -53,9 +52,6 @@
     caseContext.Set<arm::app::Profiler&>("profiler", profiler);
     caseContext.Set<arm::app::Model&>("model", model);
     caseContext.Set<uint32_t>("imgIndex", 0);
-    arm::app::object_detection::DetectorPostprocessing postp;
-    caseContext.Set<arm::app::object_detection::DetectorPostprocessing&>("postprocess", postp);
-
 
     /* Loop. */
     bool executionSuccessful = true;
diff --git a/source/use_case/object_detection/src/UseCaseHandler.cc b/source/use_case/object_detection/src/UseCaseHandler.cc
index f3b317e..332d199 100644
--- a/source/use_case/object_detection/src/UseCaseHandler.cc
+++ b/source/use_case/object_detection/src/UseCaseHandler.cc
@@ -19,6 +19,7 @@
 #include "YoloFastestModel.hpp"
 #include "UseCaseCommonUtils.hpp"
 #include "DetectorPostProcessing.hpp"
+#include "DetectorPreProcessing.hpp"
 #include "hal.h"
 #include "log_macros.h"
 
@@ -33,7 +34,7 @@
      * @param[in]       results            Vector of detection results to be displayed.
      * @return          true if successful, false otherwise.
      **/
-    static bool PresentInferenceResult(const std::vector<arm::app::object_detection::DetectionResult>& results);
+    static bool PresentInferenceResult(const std::vector<object_detection::DetectionResult>& results);
 
     /**
      * @brief           Draw boxes directly on the LCD for all detected objects.
@@ -43,12 +44,12 @@
      * @param[in]       imgDownscaleFactor How much image has been downscaled on LCD.
      **/
     static void DrawDetectionBoxes(
-            const std::vector<arm::app::object_detection::DetectionResult>& results,
+           const std::vector<object_detection::DetectionResult>& results,
            uint32_t imgStartX,
            uint32_t imgStartY,
            uint32_t imgDownscaleFactor);
 
-    /* Object detection classification handler. */
+    /* Object detection inference handler. */
     bool ObjectDetectionHandler(ApplicationContext& ctx, uint32_t imgIndex, bool runAll)
     {
         auto& profiler = ctx.Get<Profiler&>("profiler");
@@ -75,9 +76,11 @@
             return false;
         }
 
-        auto curImIdx = ctx.Get<uint32_t>("imgIndex");
+        auto initialImgIdx = ctx.Get<uint32_t>("imgIndex");
 
         TfLiteTensor* inputTensor = model.GetInputTensor(0);
+        TfLiteTensor* outputTensor0 = model.GetOutputTensor(0);
+        TfLiteTensor* outputTensor1 = model.GetOutputTensor(1);
 
         if (!inputTensor->dims) {
             printf_err("Invalid input tensor dims\n");
@@ -89,71 +92,66 @@
 
         TfLiteIntArray* inputShape = model.GetInputShape(0);
 
-        const uint32_t nCols = inputShape->data[arm::app::YoloFastestModel::ms_inputColsIdx];
-        const uint32_t nRows = inputShape->data[arm::app::YoloFastestModel::ms_inputRowsIdx];
+        const int inputImgCols = inputShape->data[YoloFastestModel::ms_inputColsIdx];
+        const int inputImgRows = inputShape->data[YoloFastestModel::ms_inputRowsIdx];
 
-        /* Get pre/post-processing objects. */
-        auto& postp = ctx.Get<object_detection::DetectorPostprocessing&>("postprocess");
+        /* Set up pre and post-processing. */
+        DetectorPreProcess preProcess = DetectorPreProcess(inputTensor, true, model.IsDataSigned());
 
+        std::vector<object_detection::DetectionResult> results;
+        DetectorPostProcess postProcess = DetectorPostProcess(outputTensor0, outputTensor1,
+                results, inputImgRows, inputImgCols);
         do {
             /* Strings for presentation/logging. */
             std::string str_inf{"Running inference... "};
 
-            const uint8_t* curr_image = get_img_array(ctx.Get<uint32_t>("imgIndex"));
+            const uint8_t* currImage = get_img_array(ctx.Get<uint32_t>("imgIndex"));
 
-            /* Copy over the data and convert to grayscale */
-            auto* dstPtr = static_cast<uint8_t*>(inputTensor->data.uint8);
+            auto dstPtr = static_cast<uint8_t*>(inputTensor->data.uint8);
             const size_t copySz = inputTensor->bytes < IMAGE_DATA_SIZE ?
                                 inputTensor->bytes : IMAGE_DATA_SIZE;
 
-            /* Convert to gray scale and populate input tensor. */
-            image::RgbToGrayscale(curr_image, dstPtr, copySz);
+            /* Run the pre-processing, inference and post-processing. */
+            if (!preProcess.DoPreProcess(currImage, copySz)) {
+                printf_err("Pre-processing failed.");
+                return false;
+            }
 
             /* Display image on the LCD. */
             hal_lcd_display_image(
-                (channelsImageDisplayed == 3) ? curr_image : dstPtr,
-                nCols, nRows, channelsImageDisplayed,
+                (channelsImageDisplayed == 3) ? currImage : dstPtr,
+                inputImgCols, inputImgRows, channelsImageDisplayed,
                 dataPsnImgStartX, dataPsnImgStartY, dataPsnImgDownscaleFactor);
 
-            /* If the data is signed. */
-            if (model.IsDataSigned()) {
-                image::ConvertImgToInt8(inputTensor->data.data, inputTensor->bytes);
-            }
-
             /* Display message on the LCD - inference running. */
             hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
+                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             /* Run inference over this image. */
             info("Running inference on image %" PRIu32 " => %s\n", ctx.Get<uint32_t>("imgIndex"),
                 get_filename(ctx.Get<uint32_t>("imgIndex")));
 
             if (!RunInference(model, profiler)) {
+                printf_err("Inference failed.");
+                return false;
+            }
+
+            if (!postProcess.DoPostProcess()) {
+                printf_err("Post-processing failed.");
                 return false;
             }
 
             /* Erase. */
             str_inf = std::string(str_inf.size(), ' ');
             hal_lcd_display_text(str_inf.c_str(), str_inf.size(),
-                                    dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
-
-            /* Detector post-processing*/
-            std::vector<object_detection::DetectionResult> results;
-            TfLiteTensor* modelOutput0 = model.GetOutputTensor(0);
-            TfLiteTensor* modelOutput1 = model.GetOutputTensor(1);
-            postp.RunPostProcessing(
-                nRows,
-                nCols,
-                modelOutput0,
-                modelOutput1,
-                results);
+                                 dataPsnTxtInfStartX, dataPsnTxtInfStartY, false);
 
             /* Draw boxes. */
             DrawDetectionBoxes(results, dataPsnImgStartX, dataPsnImgStartY, dataPsnImgDownscaleFactor);
 
 #if VERIFY_TEST_OUTPUT
-            arm::app::DumpTensor(modelOutput0);
-            arm::app::DumpTensor(modelOutput1);
+            DumpTensor(modelOutput0);
+            DumpTensor(modelOutput1);
 #endif /* VERIFY_TEST_OUTPUT */
 
             if (!PresentInferenceResult(results)) {
@@ -164,12 +162,12 @@
 
             IncrementAppCtxIfmIdx(ctx,"imgIndex");
 
-        } while (runAll && ctx.Get<uint32_t>("imgIndex") != curImIdx);
+        } while (runAll && ctx.Get<uint32_t>("imgIndex") != initialImgIdx);
 
         return true;
     }
 
-    static bool PresentInferenceResult(const std::vector<arm::app::object_detection::DetectionResult>& results)
+    static bool PresentInferenceResult(const std::vector<object_detection::DetectionResult>& results)
     {
         hal_lcd_set_text_color(COLOR_GREEN);
 
@@ -186,7 +184,7 @@
         return true;
     }
 
-    static void DrawDetectionBoxes(const std::vector<arm::app::object_detection::DetectionResult>& results,
+    static void DrawDetectionBoxes(const std::vector<object_detection::DetectionResult>& results,
                                    uint32_t imgStartX,
                                    uint32_t imgStartY,
                                    uint32_t imgDownscaleFactor)
diff --git a/tests/use_case/object_detection/InferenceTestYoloFastest.cc b/tests/use_case/object_detection/InferenceTestYoloFastest.cc
index 8ef012d..2c035e7 100644
--- a/tests/use_case/object_detection/InferenceTestYoloFastest.cc
+++ b/tests/use_case/object_detection/InferenceTestYoloFastest.cc
@@ -94,13 +94,8 @@
         REQUIRE(tflite::GetTensorData<T>(output_arr[i]));
     }
 
-    arm::app::object_detection::DetectorPostprocessing postp;
-    postp.RunPostProcessing(
-        nRows,
-        nCols,
-        output_arr[0],
-        output_arr[1],
-        results);
+    arm::app::DetectorPostProcess postp{output_arr[0], output_arr[1], results, nRows, nCols};
+    postp.DoPostProcess();
 
     std::vector<std::vector<arm::app::object_detection::DetectionResult>> expected_results;
     GetExpectedResults(expected_results);
diff --git a/tests/use_case/object_detection/ObjectDetectionUCTest.cc b/tests/use_case/object_detection/ObjectDetectionUCTest.cc
index a7e4f33..023b893 100644
--- a/tests/use_case/object_detection/ObjectDetectionUCTest.cc
+++ b/tests/use_case/object_detection/ObjectDetectionUCTest.cc
@@ -58,8 +58,6 @@
     caseContext.Set<arm::app::Profiler&>("profiler", profiler);
     caseContext.Set<arm::app::Model&>("model", model);
     caseContext.Set<uint32_t>("imgIndex", 0);
-    arm::app::object_detection::DetectorPostprocessing postp;
-    caseContext.Set<arm::app::object_detection::DetectorPostprocessing&>("postprocess", postp);
 
     REQUIRE(arm::app::ObjectDetectionHandler(caseContext, 0, false));
 }
@@ -83,8 +81,6 @@
     caseContext.Set<arm::app::Profiler&>("profiler", profiler);
     caseContext.Set<arm::app::Model&>("model", model);
     caseContext.Set<uint32_t>("imgIndex", 0);
-    arm::app::object_detection::DetectorPostprocessing postp;
-    caseContext.Set<arm::app::object_detection::DetectorPostprocessing&>("postprocess", postp);
 
     REQUIRE(arm::app::ObjectDetectionHandler(caseContext, 0, true));
 }