Merge remote-tracking branch 'upstream/3.4' into merge-3.4

diff --cc 3rdparty/libpng/CMakeLists.txt
index bb0f3dd,f72b966..973f39c
--- 1/3rdparty/libpng/CMakeLists.txt
--- 2/3rdparty/libpng/CMakeLists.txt
+++ b/3rdparty/libpng/CMakeLists.txt
@@@ -77,9 -77,9 +77,11 @@@ endif(MSVC
  add_library(${PNG_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${lib_srcs} ${lib_hdrs})
  target_link_libraries(${PNG_LIBRARY} ${ZLIB_LIBRARIES})
  
- ocv_warnings_disable(CMAKE_C_FLAGS -Wundef -Wcast-align -Wimplicit-fallthrough -Wunused-parameter -Wsign-compare)
- ocv_warnings_disable(CMAKE_C_FLAGS -Wnull-pointer-subtraction)  # clang15
- ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-but-set-variable)  # clang15
+ ocv_warnings_disable(CMAKE_C_FLAGS -Wundef -Wcast-align -Wimplicit-fallthrough -Wunused-parameter -Wsign-compare
+     -Wmaybe-uninitialized
++    -Wnull-pointer-subtraction                   # clang15
++    -Wunused-but-set-variable                    # clang15
+ )
  
  set_target_properties(${PNG_LIBRARY}
    PROPERTIES OUTPUT_NAME ${PNG_LIBRARY}

diff --cc 3rdparty/libtiff/CMakeLists.txt
index d37cfff,99c1933..826c5e2
--- 1/3rdparty/libtiff/CMakeLists.txt
--- 2/3rdparty/libtiff/CMakeLists.txt
+++ b/3rdparty/libtiff/CMakeLists.txt
@@@ -452,9 -452,9 +452,10 @@@ ocv_warnings_disable(CMAKE_C_FLAGS -Wno
                                     -Wcast-align -Wshadow -Wno-maybe-uninitialized -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast
                                     -Wmisleading-indentation
                                     -Wimplicit-fallthrough
+                                    -Wunused-parameter  # clang
+                                    -Warray-parameter
++                                   -Wstrict-prototypes  # clang15
  )
- ocv_warnings_disable(CMAKE_C_FLAGS -Wunused-parameter) # clang
- ocv_warnings_disable(CMAKE_C_FLAGS -Wstrict-prototypes) # clang15
  ocv_warnings_disable(CMAKE_CXX_FLAGS -Wmissing-declarations -Wunused-parameter -Wmissing-prototypes
      -Wundef  # tiffiop.h: #if __clang_major__ >= 4
  )

diff --cc modules/dnn/src/onnx/onnx_importer.cpp
index 8fa04a4,e4cbe02..4d47838
--- 1/modules/dnn/src/onnx/onnx_importer.cpp
--- 2/modules/dnn/src/onnx/onnx_importer.cpp
+++ b/modules/dnn/src/onnx/onnx_importer.cpp
@@@ -174,110 -194,25 +174,123 @@@ private
      void parseUpsample             (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
      void parseSoftMax              (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
      void parseDetectionOutput      (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 -    void parseCustom               (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 -
 -    const DispatchMap dispatch;
 -    static const DispatchMap buildDispatchMap();
 +    void parseCumSum               (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseDepthToSpace         (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseSimpleLayers         (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +
 +    // Domain: com.microsoft
 +    // URL: https://github.com/microsoft/onnxruntime/blob/master/docs/ContribOperators.md
 +    void parseQuantDequant         (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQConv                (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQMatMul              (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQEltwise             (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQLeakyRelu           (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQSigmoid             (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQAvgPool             (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +    void parseQConcat              (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
 +
 +    // '???' domain or '???' layer type
 +    void parseCustomLayer          (LayerParams& layerParams, const opencv_onnx::NodeProto& node_proto);
  
      int onnx_opset;  // OperatorSetIdProto for 'onnx' domain
 +    std::map<std::string, int> onnx_opset_map;  // map from OperatorSetIdProto
      void parseOperatorSet();
  
 +    const std::string str_domain_ai_onnx = "ai.onnx";
++
+ 
+     bool useLegacyNames;
+     bool getParamUseLegacyNames()
+     {
+         bool param = utils::getConfigurationParameterBool("OPENCV_DNN_ONNX_USE_LEGACY_NAMES", false);
+         return param;
+     }
+     const std::string extractNodeName(const opencv_onnx::NodeProto& node_proto);
  };
  
+ 
 +class ONNXLayerHandler : public detail::LayerHandler
 +{
 +public:
 +    explicit ONNXLayerHandler(ONNXImporter* importer_);
 +
 +    void fillRegistry(const opencv_onnx::GraphProto& net);
 +
 +protected:
 +    ONNXImporter* importer;
 +};
 +
 +ONNXLayerHandler::ONNXLayerHandler(ONNXImporter* importer_) : importer(importer_){}
 +
 +void ONNXLayerHandler::fillRegistry(const opencv_onnx::GraphProto &net)
 +{
 +    int layersSize = net.node_size();
 +    for (int li = 0; li < layersSize; li++) {
 +        const opencv_onnx::NodeProto &node_proto = net.node(li);
 +        const std::string& name = node_proto.output(0);
 +        const std::string& type = node_proto.op_type();
 +        const std::string& layer_type_domain = importer->getLayerTypeDomain(node_proto);
 +        const auto& dispatch = importer->getDispatchMap(node_proto);
 +        if (dispatch.find(type) == dispatch.end())
 +        {
 +            addMissing(name, cv::format("%s.%s", layer_type_domain.c_str(), type.c_str()));
 +        }
 +    }
 +    printMissing();
 +}
 +
 +ONNXImporter::ONNXImporter(Net& net, const char *onnxFile)
 +    : layerHandler(DNN_DIAGNOSTICS_RUN ? new ONNXLayerHandler(this) : nullptr)
 +    , dstNet(net)
 +    , onnx_opset(0)
++    , useLegacyNames(getParamUseLegacyNames())
 +{
 +    hasDynamicShapes = false;
 +    CV_Assert(onnxFile);
 +    CV_LOG_DEBUG(NULL, "DNN/ONNX: processing ONNX model from file: " << onnxFile);
 +
 +    std::fstream input(onnxFile, std::ios::in | std::ios::binary);
 +    if (!input)
 +    {
 +        CV_Error(Error::StsBadArg, cv::format("Can't read ONNX file: %s", onnxFile));
 +    }
 +
 +    if (!model_proto.ParseFromIstream(&input))
 +    {
 +        CV_Error(Error::StsUnsupportedFormat, cv::format("Failed to parse ONNX model: %s", onnxFile));
 +    }
 +
 +    populateNet();
 +}
 +
 +ONNXImporter::ONNXImporter(Net& net, const char* buffer, size_t sizeBuffer)
 +    : layerHandler(DNN_DIAGNOSTICS_RUN ? new ONNXLayerHandler(this) : nullptr)
 +    , dstNet(net)
 +    , onnx_opset(0)
++    , useLegacyNames(getParamUseLegacyNames())
 +{
 +    hasDynamicShapes = false;
 +    CV_LOG_DEBUG(NULL, "DNN/ONNX: processing in-memory ONNX model (" << sizeBuffer << " bytes)");
 +
 +    struct _Buf : public std::streambuf
 +            {
 +        _Buf(const char* buffer, size_t sizeBuffer)
 +        {
 +            char* p = const_cast<char*>(buffer);
 +            setg(p, p, p + sizeBuffer);
 +        }
 +            };
 +
 +    _Buf buf(buffer, sizeBuffer);
 +    std::istream input(&buf);
 +
 +    if (!model_proto.ParseFromIstream(&input))
 +        CV_Error(Error::StsUnsupportedFormat, "Failed to parse onnx model from in-memory byte array.");
 +
 +    populateNet();
 +}
 +
++
  inline void replaceLayerParam(LayerParams& layerParams, const String& oldKey, const String& newKey)
  {
      if (layerParams.has(oldKey)) {
@@@ -883,37 -732,17 +896,40 @@@ void ONNXImporter::populateNet(
          // no need to duplicate message from engine: CV_LOG_DEBUG(NULL, "DNN/ONNX: registered output='" << output_name << "' with id=" << outputId);
      }
  
 -    CV_LOG_DEBUG(NULL, "DNN/ONNX: import completed!");
 +    CV_LOG_DEBUG(NULL, (DNN_DIAGNOSTICS_RUN ? "DNN/ONNX: diagnostic run completed!" : "DNN/ONNX: import completed!"));
 +}
 +
 +std::string ONNXImporter::getLayerTypeDomain(const opencv_onnx::NodeProto& node_proto)
 +{
 +    if (!node_proto.has_domain())
 +        return str_domain_ai_onnx;
 +    const std::string& domain = node_proto.domain();
 +    if (domain.empty())
 +        return str_domain_ai_onnx;
 +    return domain;
 +}
 +
 +const ONNXImporter::DispatchMap& ONNXImporter::getDispatchMap(const opencv_onnx::NodeProto& node_proto)
 +{
 +    static DispatchMap empty_map;
 +    const std::string& layer_type_domain = getLayerTypeDomain(node_proto);
 +    auto it = domain_dispatch_map.find(layer_type_domain);
 +    if (it == domain_dispatch_map.end())
 +    {
 +        return empty_map;
 +    }
 +
 +    return it->second;
  }
  
- const std::string& extractNodeName(const opencv_onnx::NodeProto& node_proto)
+ const std::string ONNXImporter::extractNodeName(const opencv_onnx::NodeProto& node_proto)
  {
+     // We need to rework DNN outputs API, this is a workaround for #21698
      if (node_proto.has_name() && !node_proto.name().empty())
      {
-         return node_proto.name();
+         if (useLegacyNames)
+             return node_proto.name();
+         return cv::format("onnx_node!%s", node_proto.name().c_str());
      }
      for (int i = 0; i < node_proto.output_size(); ++i)
      {

diff --cc modules/dnn/test/test_int8_layers.cpp
index f2f00b0,0000000..8446012
mode 100644,000000..100644
--- 1/modules/dnn/test/test_int8_layers.cpp
--- /dev/null
+++ b/modules/dnn/test/test_int8_layers.cpp
@@@ -1,1267 -1,0 +1,1285 @@@
- TEST_P(Test_Int8_layers, Softmax)
 +// This file is part of OpenCV project.
 +// It is subject to the license terms in the LICENSE file found in the top-level directory
 +// of this distribution and at http://opencv.org/license.html.
 +
 +#include "test_precomp.hpp"
 +#include "npy_blob.hpp"
 +#include <opencv2/dnn/shape_utils.hpp>
 +#include <opencv2/dnn/all_layers.hpp>
 +namespace opencv_test { namespace {
 +
 +testing::internal::ParamGenerator< tuple<Backend, Target> > dnnBackendsAndTargetsInt8()
 +{
 +    std::vector< tuple<Backend, Target> > targets;
 +    targets.push_back(make_tuple(DNN_BACKEND_OPENCV, DNN_TARGET_CPU));
 +#ifdef HAVE_TIMVX
 +    targets.push_back(make_tuple(DNN_BACKEND_TIMVX, DNN_TARGET_NPU));
 +#endif
 +    return testing::ValuesIn(targets);
 +}
 +
 +template<typename TString>
 +static std::string _tf(TString filename)
 +{
 +    return (getOpenCVExtraDir() + "dnn/") + filename;
 +}
 +
 +class Test_Int8_layers : public DNNTestLayer
 +{
 +public:
 +    void testLayer(const String& basename, const String& importer, double l1, double lInf,
 +                   int numInps = 1, int numOuts = 1, bool useCaffeModel = false,
 +                   bool useCommonInputBlob = true, bool hasText = false)
 +    {
 +        CV_Assert_N(numInps >= 1, numInps <= 10, numOuts >= 1, numOuts <= 10);
 +        std::vector<Mat> inps(numInps), inps_int8(numInps);
 +        std::vector<Mat> refs(numOuts), outs_int8(numOuts), outs_dequantized(numOuts);
 +        std::vector<float> inputScale, outputScale;
 +        std::vector<int> inputZp, outputZp;
 +        String inpPath, outPath;
 +        Net net, qnet;
 +
 +        if (importer == "Caffe")
 +        {
 +            String prototxt = _tf("layers/" + basename + ".prototxt");
 +            String caffemodel = _tf("layers/" + basename + ".caffemodel");
 +            net = readNetFromCaffe(prototxt, useCaffeModel ? caffemodel : String());
 +
 +            inpPath = _tf("layers/" + (useCommonInputBlob ? "blob" : basename + ".input"));
 +            outPath =  _tf("layers/" + basename);
 +        }
 +        else if (importer == "TensorFlow")
 +        {
 +            String netPath = _tf("tensorflow/" + basename + "_net.pb");
 +            String netConfig = hasText ? _tf("tensorflow/" + basename + "_net.pbtxt") : "";
 +            net = readNetFromTensorflow(netPath, netConfig);
 +
 +            inpPath = _tf("tensorflow/" + basename + "_in");
 +            outPath = _tf("tensorflow/" + basename + "_out");
 +        }
 +        else if (importer == "ONNX")
 +        {
 +            String onnxmodel = _tf("onnx/models/" + basename + ".onnx");
 +            net = readNetFromONNX(onnxmodel);
 +
 +            inpPath = _tf("onnx/data/input_" + basename);
 +            outPath = _tf("onnx/data/output_" + basename);
 +        }
 +        ASSERT_FALSE(net.empty());
 +        net.setPreferableBackend(backend);
 +        net.setPreferableTarget(target);
 +
 +        for (int i = 0; i < numInps; i++)
 +            inps[i] = blobFromNPY(inpPath + ((numInps > 1) ? cv::format("_%d.npy", i) : ".npy"));
 +
 +        for (int i = 0; i < numOuts; i++)
 +            refs[i] = blobFromNPY(outPath + ((numOuts > 1) ? cv::format("_%d.npy", i) : ".npy"));
 +
 +        qnet = net.quantize(inps, CV_8S, CV_8S);
 +        qnet.getInputDetails(inputScale, inputZp);
 +        qnet.getOutputDetails(outputScale, outputZp);
 +
 +        // Quantize inputs to int8
 +        // int8_value = float_value/scale + zero-point
 +        for (int i = 0; i < numInps; i++)
 +        {
 +            inps[i].convertTo(inps_int8[i], CV_8S, 1.f/inputScale[i], inputZp[i]);
 +            String inp_name = numInps > 1 ? (importer == "Caffe" ? cv::format("input_%d", i) : cv::format("%d", i)) : "";
 +            qnet.setInput(inps_int8[i], inp_name);
 +        }
 +        qnet.forward(outs_int8);
 +
 +        // Dequantize outputs and compare with reference outputs
 +        // float_value = scale*(int8_value - zero-point)
 +        for (int i = 0; i < numOuts; i++)
 +        {
 +            outs_int8[i].convertTo(outs_dequantized[i], CV_32F, outputScale[i], -(outputScale[i] * outputZp[i]));
 +            normAssert(refs[i], outs_dequantized[i], "", l1, lInf);
 +        }
 +    }
 +};
 +
 +TEST_P(Test_Int8_layers, Convolution1D)
 +{
 +    testLayer("conv1d", "ONNX", 0.00302, 0.00909);
 +    testLayer("conv1d_bias", "ONNX", 0.00306, 0.00948);
 +}
 +
 +TEST_P(Test_Int8_layers, Convolution2D)
 +{
 +    if(backend == DNN_BACKEND_TIMVX)
 +        testLayer("single_conv", "TensorFlow", 0.00424, 0.02201);
 +    else
 +        testLayer("single_conv", "TensorFlow", 0.00413, 0.02201);
 +
 +    testLayer("atrous_conv2d_valid", "TensorFlow", 0.0193, 0.0633);
 +    testLayer("atrous_conv2d_same", "TensorFlow", 0.0185, 0.1322);
 +    testLayer("keras_atrous_conv2d_same", "TensorFlow", 0.0056, 0.0244);
 +
 +    if(backend == DNN_BACKEND_TIMVX)
 +        testLayer("convolution", "ONNX", 0.00534, 0.01516);
 +    else
 +        testLayer("convolution", "ONNX", 0.0052, 0.01516);
 +
 +    if(backend == DNN_BACKEND_TIMVX)
 +        testLayer("two_convolution", "ONNX", 0.0033, 0.01);
 +    else
 +        testLayer("two_convolution", "ONNX", 0.00295, 0.00840);
 +
 +    if(backend == DNN_BACKEND_TIMVX)
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_TIMVX);
 +    testLayer("layer_convolution", "Caffe", 0.0174, 0.0758, 1, 1, true);
 +    testLayer("depthwise_conv2d", "TensorFlow", 0.0388, 0.169);
 +}
 +
 +TEST_P(Test_Int8_layers, Convolution3D)
 +{
 +    testLayer("conv3d", "TensorFlow", 0.00734, 0.02434);
 +    testLayer("conv3d", "ONNX", 0.00353, 0.00941);
 +    testLayer("conv3d_bias", "ONNX", 0.00129, 0.00249);
 +}
 +
 +TEST_P(Test_Int8_layers, Flatten)
 +{
 +    testLayer("flatten", "TensorFlow", 0.0036, 0.0069, 1, 1, false, true, true);
 +    testLayer("unfused_flatten", "TensorFlow", 0.0014, 0.0028);
 +    testLayer("unfused_flatten_unknown_batch", "TensorFlow", 0.0043, 0.0051);
 +}
 +
 +TEST_P(Test_Int8_layers, Padding)
 +{
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("padding_valid", "TensorFlow", 0.0292, 0.0105);
 +    else
 +        testLayer("padding_valid", "TensorFlow", 0.0026, 0.0064);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("padding_same", "TensorFlow", 0.0085, 0.032);
 +    else
 +        testLayer("padding_same", "TensorFlow", 0.0081, 0.032);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("spatial_padding", "TensorFlow", 0.0079, 0.028);
 +    else
 +        testLayer("spatial_padding", "TensorFlow", 0.0078, 0.028);
 +
 +    testLayer("mirror_pad", "TensorFlow", 0.0064, 0.013);
 +    testLayer("pad_and_concat", "TensorFlow", 0.0021, 0.0098);
 +    testLayer("padding", "ONNX", 0.0005, 0.0069);
 +    testLayer("ReflectionPad2d", "ONNX", 0.00062, 0.0018);
 +    testLayer("ZeroPad2d", "ONNX", 0.00037, 0.0018);
 +}
 +
 +TEST_P(Test_Int8_layers, AvePooling)
 +{
 +    testLayer("layer_pooling_ave", "Caffe", 0.0021, 0.0075);
 +    testLayer("ave_pool_same", "TensorFlow", 0.00153, 0.0041);
 +    testLayer("average_pooling_1d", "ONNX", 0.002, 0.0048);
 +    testLayer("average_pooling", "ONNX", 0.0014, 0.0032);
 +    testLayer("average_pooling_dynamic_axes", "ONNX", 0.0014, 0.006);
 +
 +    if (target != DNN_TARGET_CPU)
 +        throw SkipTestException("Only CPU is supported");
 +    testLayer("ave_pool3d", "TensorFlow", 0.00175, 0.0047);
 +    testLayer("ave_pool3d", "ONNX", 0.00063, 0.0016);
 +}
 +
 +TEST_P(Test_Int8_layers, MaxPooling)
 +{
 +    testLayer("pool_conv_1d", "ONNX", 0.0006, 0.0015);
 +    if (target != DNN_TARGET_CPU)
 +        throw SkipTestException("Only CPU is supported");
 +    testLayer("pool_conv_3d", "ONNX", 0.0033, 0.0124);
 +
 +    /* All the below tests have MaxPooling as last layer, so computeMaxIdx is set to true
 +       which is not supported by int8 maxpooling
 +    testLayer("layer_pooling_max", "Caffe", 0.0021, 0.004);
 +    testLayer("max_pool_even", "TensorFlow", 0.0048, 0.0139);
 +    testLayer("max_pool_odd_valid", "TensorFlow", 0.0043, 0.012);
 +    testLayer("conv_pool_nchw", "TensorFlow", 0.007, 0.025);
 +    testLayer("max_pool3d", "TensorFlow", 0.0025, 0.0058);
 +    testLayer("maxpooling_1d", "ONNX", 0.0018, 0.0037);
 +    testLayer("two_maxpooling_1d", "ONNX", 0.0037, 0.0052);
 +    testLayer("maxpooling", "ONNX", 0.0034, 0.0065);
 +    testLayer("two_maxpooling", "ONNX", 0.0025, 0.0052);
 +    testLayer("max_pool3d", "ONNX", 0.0028, 0.0069);*/
 +}
 +
 +TEST_P(Test_Int8_layers, Reduce)
 +{
 +    testLayer("reduce_mean", "TensorFlow", 0.0005, 0.0014);
 +    testLayer("reduce_mean", "ONNX", 0.00062, 0.0014);
 +    testLayer("reduce_mean_axis1", "ONNX", 0.00032, 0.0007);
 +    testLayer("reduce_mean_axis2", "ONNX", 0.00033, 0.001);
 +
 +    testLayer("reduce_sum", "TensorFlow", 0.015, 0.031);
 +    testLayer("reduce_sum_channel", "TensorFlow", 0.008, 0.019);
 +    testLayer("sum_pool_by_axis", "TensorFlow", 0.012, 0.032);
 +    testLayer("reduce_sum", "ONNX", 0.0025, 0.0048);
 +
 +    testLayer("reduce_max", "ONNX", 0, 0);
 +    testLayer("reduce_max_axis_0", "ONNX", 0.0042, 0.007);
 +    testLayer("reduce_max_axis_1", "ONNX", 0.0018, 0.0036);
 +
 +    if (target != DNN_TARGET_CPU)
 +        throw SkipTestException("Only CPU is supported");
 +    testLayer("reduce_mean3d", "ONNX", 0.00048, 0.0016);
 +}
 +
 +TEST_P(Test_Int8_layers, ReLU)
 +{
 +    testLayer("layer_relu", "Caffe", 0.0005, 0.002);
 +    testLayer("ReLU", "ONNX", 0.0012, 0.0047);
 +}
 +
 +TEST_P(Test_Int8_layers, LeakyReLU)
 +{
 +    testLayer("leaky_relu", "TensorFlow", 0.0002, 0.0004);
 +}
 +
 +TEST_P(Test_Int8_layers, ReLU6)
 +{
 +    testLayer("keras_relu6", "TensorFlow", 0.0018, 0.0062);
 +    testLayer("keras_relu6", "TensorFlow", 0.0018, 0.0062, 1, 1, false, true, true);
 +    testLayer("clip_by_value", "TensorFlow", 0.0009, 0.002);
 +    testLayer("clip", "ONNX", 0.00006, 0.00037);
 +}
 +
 +TEST_P(Test_Int8_layers, Sigmoid)
 +{
 +    testLayer("maxpooling_sigmoid", "ONNX", 0.0011, 0.0032);
 +}
 +
 +TEST_P(Test_Int8_layers, Sigmoid_dynamic_axes)
 +{
 +    testLayer("maxpooling_sigmoid_dynamic_axes", "ONNX", 0.002, 0.0032);
 +}
 +
 +TEST_P(Test_Int8_layers, Sigmoid_1d)
 +{
 +    testLayer("maxpooling_sigmoid_1d", "ONNX", 0.002, 0.0037);
 +}
 +
 +TEST_P(Test_Int8_layers, Mish)
 +{
 +    testLayer("mish", "ONNX", 0.0015, 0.0025);
 +}
 +
- TEST_P(Test_Int8_layers, Slice_onnx)
++TEST_P(Test_Int8_layers, Softmax_Caffe)
 +{
 +    testLayer("layer_softmax", "Caffe", 0.0011, 0.0036);
++}
++TEST_P(Test_Int8_layers, Softmax_keras_TF)
++{
 +    testLayer("keras_softmax", "TensorFlow", 0.00093, 0.0027);
++}
++TEST_P(Test_Int8_layers, Softmax_slim_TF)
++{
 +    testLayer("slim_softmax", "TensorFlow", 0.0016, 0.0034);
++}
++TEST_P(Test_Int8_layers, Softmax_slim_v2_TF)
++{
 +    testLayer("slim_softmax_v2", "TensorFlow", 0.0029, 0.017);
++}
++TEST_P(Test_Int8_layers, Softmax_ONNX)
++{
 +    testLayer("softmax", "ONNX", 0.0016, 0.0028);
++}
++TEST_P(Test_Int8_layers, Softmax_log_ONNX)
++{
 +    testLayer("log_softmax", "ONNX", 0.014, 0.025);
++}
++TEST_P(Test_Int8_layers, DISABLED_Softmax_unfused_ONNX)  // FIXIT Support 'Identity' layer for outputs (#22022)
++{
 +    testLayer("softmax_unfused", "ONNX", 0.0009, 0.0021);
 +}
 +
 +TEST_P(Test_Int8_layers, Concat)
 +{
 +    testLayer("layer_concat_shared_input", "Caffe", 0.0076, 0.029, 1, 1, true, false);
 +    testLayer("concat_axis_1", "TensorFlow", 0.0056, 0.017);
 +    testLayer("keras_pad_concat", "TensorFlow", 0.0032, 0.0089);
 +    testLayer("concat_3d", "TensorFlow", 0.005, 0.014);
 +    testLayer("concatenation", "ONNX", 0.0032, 0.009);
 +}
 +
 +TEST_P(Test_Int8_layers, BatchNorm)
 +{
 +    testLayer("layer_batch_norm", "Caffe", 0.0061, 0.019, 1, 1, true);
 +    testLayer("fused_batch_norm", "TensorFlow", 0.0063, 0.02);
 +    testLayer("batch_norm_text", "TensorFlow", 0.0048, 0.013, 1, 1, false, true, true);
 +    testLayer("unfused_batch_norm", "TensorFlow", 0.0076, 0.019);
 +    testLayer("fused_batch_norm_no_gamma", "TensorFlow", 0.0067, 0.015);
 +    testLayer("unfused_batch_norm_no_gamma", "TensorFlow", 0.0123, 0.044);
 +    testLayer("switch_identity", "TensorFlow", 0.0035, 0.011);
 +    testLayer("batch_norm3d", "TensorFlow", 0.0077, 0.02);
 +    testLayer("batch_norm", "ONNX", 0.0012, 0.0049);
 +    testLayer("batch_norm_3d", "ONNX", 0.0039, 0.012);
 +    testLayer("frozenBatchNorm2d", "ONNX", 0.001, 0.0018);
 +    testLayer("batch_norm_subgraph", "ONNX", 0.0049, 0.0098);
 +}
 +
 +TEST_P(Test_Int8_layers, Scale)
 +{
 +    testLayer("batch_norm", "TensorFlow", 0.0028, 0.0098);
 +    testLayer("scale", "ONNX", 0.0025, 0.0071);
 +    testLayer("expand_hw", "ONNX", 0.0012, 0.0012);
 +    testLayer("flatten_const", "ONNX", 0.0024, 0.0048);
 +}
 +
 +TEST_P(Test_Int8_layers, InnerProduct)
 +{
 +    testLayer("layer_inner_product", "Caffe", 0.005, 0.02, 1, 1, true);
 +    testLayer("matmul", "TensorFlow", 0.0061, 0.019);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("nhwc_transpose_reshape_matmul", "TensorFlow", 0.0018, 0.0175);
 +    else
 +        testLayer("nhwc_transpose_reshape_matmul", "TensorFlow", 0.0009, 0.0091);
 +
 +    testLayer("nhwc_reshape_matmul", "TensorFlow", 0.03, 0.071);
 +    testLayer("matmul_layout", "TensorFlow", 0.035, 0.06);
 +    testLayer("tf2_dense", "TensorFlow", 0, 0);
 +    testLayer("matmul_add", "ONNX", 0.041, 0.082);
 +    testLayer("linear", "ONNX", 0.0018, 0.0029);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("constant", "ONNX", 0.00048, 0.0013);
 +    else
 +        testLayer("constant", "ONNX", 0.00021, 0.0006);
 +
 +    testLayer("lin_with_constant", "ONNX", 0.0011, 0.0016);
 +}
 +
 +TEST_P(Test_Int8_layers, Reshape)
 +{
 +    testLayer("reshape_layer", "TensorFlow", 0.0032, 0.0082);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("reshape_nchw", "TensorFlow", 0.0092, 0.0495);
 +    else
 +        testLayer("reshape_nchw", "TensorFlow", 0.0089, 0.029);
 +
 +    testLayer("reshape_conv", "TensorFlow", 0.035, 0.054);
 +    testLayer("reshape_reduce", "TensorFlow", 0.0042, 0.0078);
 +    testLayer("reshape_as_shape", "TensorFlow", 0.0014, 0.0028);
 +    testLayer("reshape_no_reorder", "TensorFlow", 0.0014, 0.0028);
 +    testLayer("shift_reshape_no_reorder", "TensorFlow", 0.0063, 0.014);
 +    testLayer("dynamic_reshape", "ONNX", 0.0047, 0.0079);
 +    testLayer("dynamic_reshape_opset_11", "ONNX", 0.0048, 0.0081);
 +    testLayer("flatten_by_prod", "ONNX", 0.0048, 0.0081);
 +    testLayer("squeeze", "ONNX", 0.0048, 0.0081);
 +    testLayer("unsqueeze", "ONNX", 0.0033, 0.0053);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        testLayer("squeeze_and_conv_dynamic_axes", "ONNX", 0.006, 0.0212);
 +    else
 +        testLayer("squeeze_and_conv_dynamic_axes", "ONNX", 0.0054, 0.0154);
 +
 +    testLayer("unsqueeze_and_conv_dynamic_axes", "ONNX", 0.0037, 0.0151);
 +}
 +
 +TEST_P(Test_Int8_layers, Permute)
 +{
 +    testLayer("tf2_permute_nhwc_ncwh", "TensorFlow", 0.0028, 0.006);
 +    testLayer("transpose", "ONNX", 0.0015, 0.0046);
 +}
 +
 +TEST_P(Test_Int8_layers, Identity)
 +{
 +    testLayer("expand_batch", "ONNX", 0.0027, 0.0036);
 +    testLayer("expand_channels", "ONNX", 0.0013, 0.0019);
 +    testLayer("expand_neg_batch", "ONNX", 0.00071, 0.0019);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_split_tf)
 +{
 +    testLayer("split", "TensorFlow", 0.0033, 0.0056);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_4d_tf)
 +{
 +    testLayer("slice_4d", "TensorFlow", 0.003, 0.0073);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_strided_tf)
 +{
 +    testLayer("strided_slice", "TensorFlow", 0.008, 0.0142);
 +}
 +
++TEST_P(Test_Int8_layers, DISABLED_Slice_onnx)  // FIXIT Support 'Identity' layer for outputs (#22022)
 +{
 +    testLayer("slice", "ONNX", 0.0046, 0.0077);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_dynamic_axes_onnx)
 +{
 +    testLayer("slice_dynamic_axes", "ONNX", 0.0039, 0.02);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_steps_2d_onnx11)
 +{
 +    testLayer("slice_opset_11_steps_2d", "ONNX", 0.01, 0.0124);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_steps_3d_onnx11)
 +{
 +    testLayer("slice_opset_11_steps_3d", "ONNX", 0.0068, 0.014);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_steps_4d_onnx11)
 +{
 +    testLayer("slice_opset_11_steps_4d", "ONNX", 0.0041, 0.008);
 +}
 +
 +TEST_P(Test_Int8_layers, Slice_steps_5d_onnx11)
 +{
 +    testLayer("slice_opset_11_steps_5d", "ONNX", 0.0085, 0.021);
 +}
 +
 +TEST_P(Test_Int8_layers, Dropout)
 +{
 +    testLayer("layer_dropout", "Caffe", 0.0021, 0.004);
 +    testLayer("dropout", "ONNX", 0.0029, 0.004);
 +}
 +
 +TEST_P(Test_Int8_layers, Eltwise)
 +{
 +    testLayer("layer_eltwise", "Caffe", 0.062, 0.15);
 +
 +    if (backend == DNN_BACKEND_TIMVX)
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_TIMVX);
 +
 +    testLayer("conv_2_inps", "Caffe", 0.0086, 0.0232, 2, 1, true, false);
 +    testLayer("eltwise_sub", "TensorFlow", 0.015, 0.047);
 +    testLayer("eltwise_add_vec", "TensorFlow", 0.037, 0.21); // tflite 0.0095, 0.0365
 +    testLayer("eltwise_mul_vec", "TensorFlow", 0.173, 1.14); // tflite 0.0028, 0.017
 +    testLayer("channel_broadcast", "TensorFlow", 0.0025, 0.0063);
 +    testLayer("split_equals", "TensorFlow", 0.02, 0.065);
 +    testLayer("mul", "ONNX", 0.0039, 0.014);
 +    testLayer("split_max", "ONNX", 0.004, 0.012);
 +}
 +
 +INSTANTIATE_TEST_CASE_P(/**/, Test_Int8_layers, dnnBackendsAndTargetsInt8());
 +
 +class Test_Int8_nets : public DNNTestLayer
 +{
 +public:
 +    void testClassificationNet(Net baseNet, const Mat& blob, const Mat& ref, double l1, double lInf)
 +    {
 +        Net qnet = baseNet.quantize(blob, CV_32F, CV_32F);
 +        qnet.setPreferableBackend(backend);
 +        qnet.setPreferableTarget(target);
 +
 +        qnet.setInput(blob);
 +        Mat out = qnet.forward();
 +        normAssert(ref, out, "", l1, lInf);
 +    }
 +
 +    void testDetectionNet(Net baseNet, const Mat& blob, const Mat& ref,
 +                          double confThreshold, double scoreDiff, double iouDiff)
 +    {
 +        Net qnet = baseNet.quantize(blob, CV_32F, CV_32F);
 +        qnet.setPreferableBackend(backend);
 +        qnet.setPreferableTarget(target);
 +
 +        qnet.setInput(blob);
 +        Mat out = qnet.forward();
 +        normAssertDetections(ref, out, "", confThreshold, scoreDiff, iouDiff);
 +    }
 +
 +    void testFaster(Net baseNet, const Mat& ref, double confThreshold, double scoreDiff, double iouDiff)
 +    {
 +        Mat inp = imread(_tf("dog416.png"));
 +        resize(inp, inp, Size(800, 600));
 +        Mat blob = blobFromImage(inp, 1.0, Size(), Scalar(102.9801, 115.9465, 122.7717), false, false);
 +        Mat imInfo = (Mat_<float>(1, 3) << inp.rows, inp.cols, 1.6f);
 +
 +        Net qnet = baseNet.quantize(std::vector<Mat>{blob, imInfo}, CV_32F, CV_32F);
 +        qnet.setPreferableBackend(backend);
 +        qnet.setPreferableTarget(target);
 +
 +        qnet.setInput(blob, "data");
 +        qnet.setInput(imInfo, "im_info");
 +        Mat out = qnet.forward();
 +        normAssertDetections(ref, out, "", confThreshold, scoreDiff, iouDiff);
 +    }
 +
 +    void testONNXNet(const String& basename, double l1, double lInf, bool useSoftmax = false)
 +    {
 +        String onnxmodel = findDataFile("dnn/onnx/models/" + basename + ".onnx", false);
 +
 +        Mat blob = readTensorFromONNX(findDataFile("dnn/onnx/data/input_" + basename + ".pb"));
 +        Mat ref = readTensorFromONNX(findDataFile("dnn/onnx/data/output_" + basename + ".pb"));
 +        Net baseNet = readNetFromONNX(onnxmodel);
 +        baseNet.setPreferableBackend(backend);
 +        baseNet.setPreferableTarget(target);
 +
 +        Net qnet = baseNet.quantize(blob, CV_32F, CV_32F);
 +        qnet.setInput(blob);
 +        Mat out = qnet.forward();
 +
 +        if (useSoftmax)
 +        {
 +            LayerParams lp;
 +            Net netSoftmax;
 +            netSoftmax.addLayerToPrev("softmaxLayer", "Softmax", lp);
 +            netSoftmax.setPreferableBackend(DNN_BACKEND_OPENCV);
 +
 +            netSoftmax.setInput(out);
 +            out = netSoftmax.forward();
 +
 +            netSoftmax.setInput(ref);
 +            ref = netSoftmax.forward();
 +        }
 +
 +        normAssert(ref, out, "", l1, lInf);
 +    }
 +
 +    void testDarknetModel(const std::string& cfg, const std::string& weights,
 +                          const cv::Mat& ref, double scoreDiff, double iouDiff,
 +                          float confThreshold = 0.24, float nmsThreshold = 0.4)
 +    {
 +        CV_Assert(ref.cols == 7);
 +        std::vector<std::vector<int> > refClassIds;
 +        std::vector<std::vector<float> > refScores;
 +        std::vector<std::vector<Rect2d> > refBoxes;
 +        for (int i = 0; i < ref.rows; ++i)
 +        {
 +            int batchId = static_cast<int>(ref.at<float>(i, 0));
 +            int classId = static_cast<int>(ref.at<float>(i, 1));
 +            float score = ref.at<float>(i, 2);
 +            float left  = ref.at<float>(i, 3);
 +            float top   = ref.at<float>(i, 4);
 +            float right  = ref.at<float>(i, 5);
 +            float bottom = ref.at<float>(i, 6);
 +            Rect2d box(left, top, right - left, bottom - top);
 +            if (batchId >= refClassIds.size())
 +            {
 +                refClassIds.resize(batchId + 1);
 +                refScores.resize(batchId + 1);
 +                refBoxes.resize(batchId + 1);
 +            }
 +            refClassIds[batchId].push_back(classId);
 +            refScores[batchId].push_back(score);
 +            refBoxes[batchId].push_back(box);
 +        }
 +
 +        Mat img1 = imread(_tf("dog416.png"));
 +        Mat img2 = imread(_tf("street.png"));
 +        std::vector<Mat> samples(2);
 +        samples[0] = img1; samples[1] = img2;
 +
 +        // determine test type, whether batch or single img
 +        int batch_size = refClassIds.size();
 +        CV_Assert(batch_size == 1 || batch_size == 2);
 +        samples.resize(batch_size);
 +
 +        Mat inp = blobFromImages(samples, 1.0/255, Size(416, 416), Scalar(), true, false);
 +
 +        Net baseNet = readNetFromDarknet(findDataFile("dnn/" + cfg), findDataFile("dnn/" + weights, false));
 +        Net qnet = baseNet.quantize(inp, CV_32F, CV_32F);
 +        qnet.setPreferableBackend(backend);
 +        qnet.setPreferableTarget(target);
 +        qnet.setInput(inp);
 +        std::vector<Mat> outs;
 +        qnet.forward(outs, qnet.getUnconnectedOutLayersNames());
 +
 +        for (int b = 0; b < batch_size; ++b)
 +        {
 +            std::vector<int> classIds;
 +            std::vector<float> confidences;
 +            std::vector<Rect2d> boxes;
 +            for (int i = 0; i < outs.size(); ++i)
 +            {
 +                Mat out;
 +                if (batch_size > 1){
 +                    // get the sample slice from 3D matrix (batch, box, classes+5)
 +                    Range ranges[3] = {Range(b, b+1), Range::all(), Range::all()};
 +                    out = outs[i](ranges).reshape(1, outs[i].size[1]);
 +                }else{
 +                    out = outs[i];
 +                }
 +                for (int j = 0; j < out.rows; ++j)
 +                {
 +                    Mat scores = out.row(j).colRange(5, out.cols);
 +                    double confidence;
 +                    Point maxLoc;
 +                    minMaxLoc(scores, 0, &confidence, 0, &maxLoc);
 +
 +                    if (confidence > confThreshold) {
 +                        float* detection = out.ptr<float>(j);
 +                        double centerX = detection[0];
 +                        double centerY = detection[1];
 +                        double width = detection[2];
 +                        double height = detection[3];
 +                        boxes.push_back(Rect2d(centerX - 0.5 * width, centerY - 0.5 * height,
 +                                            width, height));
 +                        confidences.push_back(confidence);
 +                        classIds.push_back(maxLoc.x);
 +                    }
 +                }
 +            }
 +
 +            // here we need NMS of boxes
 +            std::vector<int> indices;
 +            NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
 +
 +            std::vector<int> nms_classIds;
 +            std::vector<float> nms_confidences;
 +            std::vector<Rect2d> nms_boxes;
 +
 +            for (size_t i = 0; i < indices.size(); ++i)
 +            {
 +                int idx = indices[i];
 +                Rect2d box = boxes[idx];
 +                float conf = confidences[idx];
 +                int class_id = classIds[idx];
 +                nms_boxes.push_back(box);
 +                nms_confidences.push_back(conf);
 +                nms_classIds.push_back(class_id);
 +            }
 +
 +            if (cvIsNaN(iouDiff))
 +            {
 +                if (b == 0)
 +                    std::cout << "Skip accuracy checks" << std::endl;
 +                continue;
 +            }
 +
 +            normAssertDetections(refClassIds[b], refScores[b], refBoxes[b], nms_classIds, nms_confidences, nms_boxes,
 +                                 format("batch size %d, sample %d\n", batch_size, b).c_str(), confThreshold, scoreDiff, iouDiff);
 +        }
 +    }
 +};
 +
 +TEST_P(Test_Int8_nets, AlexNet)
 +{
 +#if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL)
 +    applyTestTag(CV_TEST_TAG_MEMORY_2GB);
 +#else
 +    applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 +#endif
 +    if (backend != DNN_BACKEND_OPENCV)
 +        throw SkipTestException("Only OpenCV backend is supported");
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/bvlc_alexnet.prototxt"),
 +                               findDataFile("dnn/bvlc_alexnet.caffemodel", false));
 +
 +    Mat inp = imread(_tf("grace_hopper_227.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(227, 227), Scalar(), false);
 +    Mat ref = blobFromNPY(_tf("caffe_alexnet_prob.npy"));
 +
 +    float l1 = 1e-4, lInf = 0.003;
 +    testClassificationNet(net, blob, ref, l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, GoogLeNet)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/bvlc_googlenet.prototxt"),
 +                               findDataFile("dnn/bvlc_googlenet.caffemodel", false));
 +
 +    std::vector<Mat> inpMats;
 +    inpMats.push_back( imread(_tf("googlenet_0.png")) );
 +    inpMats.push_back( imread(_tf("googlenet_1.png")) );
 +    Mat blob = blobFromImages(inpMats, 1.0, Size(224, 224), Scalar(), false);
 +    Mat ref = blobFromNPY(_tf("googlenet_prob.npy"));
 +
 +    float l1 = 2e-4, lInf = 0.06;
 +    testClassificationNet(net, blob, ref, l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, ResNet50)
 +{
 +    applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 +    if (backend != DNN_BACKEND_OPENCV)
 +        throw SkipTestException("Only OpenCV backend is supported");
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/ResNet-50-deploy.prototxt"),
 +                               findDataFile("dnn/ResNet-50-model.caffemodel", false));
 +
 +    Mat inp = imread(_tf("googlenet_0.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(224, 224), Scalar(), false);
 +    Mat ref = blobFromNPY(_tf("resnet50_prob.npy"));
 +
 +    float l1 = 3e-4, lInf = 0.04;
 +    testClassificationNet(net, blob, ref, l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, DenseNet121)
 +{
 +    applyTestTag(CV_TEST_TAG_MEMORY_512MB);
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/DenseNet_121.prototxt", false),
 +                               findDataFile("dnn/DenseNet_121.caffemodel", false));
 +
 +    Mat inp = imread(_tf("dog416.png"));
 +    Mat blob = blobFromImage(inp, 1.0 / 255.0, Size(224, 224), Scalar(), true, true);
 +    Mat ref = blobFromNPY(_tf("densenet_121_output.npy"));
 +
 +    float l1 = 0.76, lInf = 3.31; // seems wrong
 +    testClassificationNet(net, blob, ref, l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, SqueezeNet_v1_1)
 +{
 +    if(target == DNN_TARGET_OPENCL_FP16)
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/squeezenet_v1.1.prototxt"),
 +                               findDataFile("dnn/squeezenet_v1.1.caffemodel", false));
 +
 +    Mat inp = imread(_tf("googlenet_0.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(227, 227), Scalar(), false, true);
 +    Mat ref = blobFromNPY(_tf("squeezenet_v1.1_prob.npy"));
 +
 +    float l1 = 3e-4, lInf = 0.056;
 +    testClassificationNet(net, blob, ref, l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, CaffeNet)
 +{
 +#if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
 +    applyTestTag(CV_TEST_TAG_MEMORY_2GB);
 +#else
 +    applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 +#endif
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    float l1 = 4e-5, lInf = 0.0025;
 +    testONNXNet("caffenet", l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, RCNN_ILSVRC13)
 +{
 +#if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
 +    applyTestTag(CV_TEST_TAG_MEMORY_2GB);
 +#else
 +    applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 +#endif
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    float l1 = 0.02, lInf = 0.042;
 +    testONNXNet("rcnn_ilsvrc13", l1, lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, Inception_v2)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    testONNXNet("inception_v2",  default_l1,  default_lInf, true);
 +}
 +
 +TEST_P(Test_Int8_nets, MobileNet_v2)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    testONNXNet("mobilenetv2", default_l1, default_lInf, true);
 +}
 +
 +TEST_P(Test_Int8_nets, Shufflenet)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    testONNXNet("shufflenet", default_l1, default_lInf);
 +}
 +
 +TEST_P(Test_Int8_nets, MobileNet_SSD)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/MobileNetSSD_deploy.prototxt", false),
 +                               findDataFile("dnn/MobileNetSSD_deploy.caffemodel", false));
 +
 +    Mat inp = imread(_tf("street.png"));
 +    Mat blob = blobFromImage(inp, 1.0 / 127.5, Size(300, 300), Scalar(127.5, 127.5, 127.5), false);
 +    Mat ref = blobFromNPY(_tf("mobilenet_ssd_caffe_out.npy"));
 +
 +    float confThreshold = FLT_MIN, scoreDiff = 0.059, iouDiff = 0.11;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, MobileNet_v1_SSD)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromTensorflow(findDataFile("dnn/ssd_mobilenet_v1_coco_2017_11_17.pb", false),
 +                                    findDataFile("dnn/ssd_mobilenet_v1_coco_2017_11_17.pbtxt"));
 +
 +    Mat inp = imread(_tf("dog416.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(300, 300), Scalar(), true, false);
 +    Mat ref = blobFromNPY(_tf("tensorflow/ssd_mobilenet_v1_coco_2017_11_17.detection_out.npy"));
 +
 +    float confThreshold = 0.5, scoreDiff = 0.034, iouDiff = 0.13;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, MobileNet_v1_SSD_PPN)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromTensorflow(findDataFile("dnn/ssd_mobilenet_v1_ppn_coco.pb", false),
 +                                    findDataFile("dnn/ssd_mobilenet_v1_ppn_coco.pbtxt"));
 +
 +    Mat inp = imread(_tf("dog416.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(300, 300), Scalar(), true, false);
 +    Mat ref = blobFromNPY(_tf("tensorflow/ssd_mobilenet_v1_ppn_coco.detection_out.npy"));
 +
 +    float confThreshold = 0.51, scoreDiff = 0.05, iouDiff = 0.06;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, Inception_v2_SSD)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 +
 +    Net net = readNetFromTensorflow(findDataFile("dnn/ssd_inception_v2_coco_2017_11_17.pb", false),
 +                                    findDataFile("dnn/ssd_inception_v2_coco_2017_11_17.pbtxt"));
 +
 +    Mat inp = imread(_tf("street.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(300, 300), Scalar(), true, false);
 +    Mat ref = (Mat_<float>(5, 7) << 0, 1, 0.90176028, 0.19872092, 0.36311883, 0.26461923, 0.63498729,
 +                                    0, 3, 0.93569964, 0.64865261, 0.45906419, 0.80675775, 0.65708131,
 +                                    0, 3, 0.75838411, 0.44668293, 0.45907149, 0.49459291, 0.52197015,
 +                                    0, 10, 0.95932811, 0.38349164, 0.32528657, 0.40387636, 0.39165527,
 +                                    0, 10, 0.93973452, 0.66561931, 0.37841269, 0.68074018, 0.42907384);
 +
 +    float confThreshold = 0.5, scoreDiff = 0.0114, iouDiff = 0.22;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, opencv_face_detector)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/opencv_face_detector.prototxt"),
 +                               findDataFile("dnn/opencv_face_detector.caffemodel", false));
 +
 +    Mat inp = imread(findDataFile("gpu/lbpcascade/er.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(), Scalar(104.0, 177.0, 123.0), false, false);
 +    Mat ref = (Mat_<float>(6, 7) << 0, 1, 0.99520785, 0.80997437, 0.16379407, 0.87996572, 0.26685631,
 +                                    0, 1, 0.9934696, 0.2831718, 0.50738752, 0.345781, 0.5985168,
 +                                    0, 1, 0.99096733, 0.13629119, 0.24892329, 0.19756334, 0.3310290,
 +                                    0, 1, 0.98977017, 0.23901358, 0.09084064, 0.29902688, 0.1769477,
 +                                    0, 1, 0.97203469, 0.67965847, 0.06876482, 0.73999709, 0.1513494,
 +                                    0, 1, 0.95097077, 0.51901293, 0.45863652, 0.5777427, 0.5347801);
 +
 +    float confThreshold = 0.5, scoreDiff = 0.002, iouDiff = 0.4;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, EfficientDet)
 +{
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +    if (backend == DNN_BACKEND_TIMVX)
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_TIMVX);
 +
 +    if (target != DNN_TARGET_CPU)
 +    {
 +        if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +        if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +        if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD);
 +    }
 +    Net net = readNetFromTensorflow(findDataFile("dnn/efficientdet-d0.pb", false),
 +                                    findDataFile("dnn/efficientdet-d0.pbtxt"));
 +
 +    Mat inp = imread(_tf("dog416.png"));
 +    Mat blob = blobFromImage(inp, 1.0/255, Size(512, 512), Scalar(123.675, 116.28, 103.53));
 +    Mat ref = (Mat_<float>(3, 7) << 0, 1, 0.8437444, 0.153996080160141, 0.20534580945968628, 0.7463544607162476, 0.7414066195487976,
 +                                    0, 17, 0.8245924, 0.16657517850399017, 0.3996818959712982, 0.4111558794975281, 0.9306337833404541,
 +                                    0, 7, 0.8039304, 0.6118435263633728, 0.13175517320632935, 0.9065558314323425, 0.2943994700908661);
 +
 +    float confThreshold = 0.65, scoreDiff = 0.17, iouDiff = 0.18;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, FasterRCNN_resnet50)
 +{
 +    applyTestTag(
 +        (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_1GB : CV_TEST_TAG_MEMORY_2GB),
 +        CV_TEST_TAG_LONG,
 +        CV_TEST_TAG_DEBUG_VERYLONG
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +
 +    Net net = readNetFromTensorflow(findDataFile("dnn/faster_rcnn_resnet50_coco_2018_01_28.pb", false),
 +                                    findDataFile("dnn/faster_rcnn_resnet50_coco_2018_01_28.pbtxt"));
 +
 +    Mat inp = imread(_tf("dog416.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(800, 600), Scalar(), true, false);
 +    Mat ref = blobFromNPY(_tf("tensorflow/faster_rcnn_resnet50_coco_2018_01_28.detection_out.npy"));
 +
 +    float confThreshold = 0.5, scoreDiff = 0.05, iouDiff = 0.15;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, FasterRCNN_inceptionv2)
 +{
 +    applyTestTag(
 +        (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_1GB : CV_TEST_TAG_MEMORY_2GB),
 +        CV_TEST_TAG_LONG,
 +        CV_TEST_TAG_DEBUG_VERYLONG
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +
 +    Net net = readNetFromTensorflow(findDataFile("dnn/faster_rcnn_inception_v2_coco_2018_01_28.pb", false),
 +                                    findDataFile("dnn/faster_rcnn_inception_v2_coco_2018_01_28.pbtxt"));
 +
 +    Mat inp = imread(_tf("dog416.png"));
 +    Mat blob = blobFromImage(inp, 1.0, Size(800, 600), Scalar(), true, false);
 +    Mat ref = blobFromNPY(_tf("tensorflow/faster_rcnn_inception_v2_coco_2018_01_28.detection_out.npy"));
 +
 +    float confThreshold = 0.5, scoreDiff = 0.21, iouDiff = 0.1;
 +    testDetectionNet(net, blob, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, FasterRCNN_vgg16)
 +{
 +    applyTestTag(
 +#if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL)
 +        CV_TEST_TAG_MEMORY_2GB,
 +#else
 +        (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_1GB : CV_TEST_TAG_MEMORY_2GB),
 +#endif
 +        CV_TEST_TAG_LONG,
 +        CV_TEST_TAG_DEBUG_VERYLONG
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/faster_rcnn_vgg16.prototxt"),
 +                               findDataFile("dnn/VGG16_faster_rcnn_final.caffemodel", false));
 +
 +    Mat ref = (Mat_<float>(3, 7) << 0, 2, 0.949398, 99.2454, 210.141, 601.205, 462.849,
 +                                    0, 7, 0.997022, 481.841, 92.3218, 722.685, 175.953,
 +                                    0, 12, 0.993028, 133.221, 189.377, 350.994, 563.166);
 +
 +    float confThreshold = 0.8, scoreDiff = 0.024, iouDiff = 0.35;
 +    testFaster(net, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, FasterRCNN_zf)
 +{
 +    applyTestTag(
 +#if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL)
 +        CV_TEST_TAG_MEMORY_2GB,
 +#else
 +        (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB),
 +#endif
 +        CV_TEST_TAG_DEBUG_LONG
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/faster_rcnn_zf.prototxt"),
 +                               findDataFile("dnn/ZF_faster_rcnn_final.caffemodel", false));
 +
 +    Mat ref = (Mat_<float>(3, 7) << 0, 2, 0.90121, 120.407, 115.83, 570.586, 528.395,
 +                                    0, 7, 0.988779, 469.849, 75.1756, 718.64, 186.762,
 +                                    0, 12, 0.967198, 138.588, 206.843, 329.766, 553.176);
 +
 +    float confThreshold = 0.8, scoreDiff = 0.021, iouDiff = 0.1;
 +    testFaster(net, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, RFCN)
 +{
 +    applyTestTag(
 +        (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_2GB),
 +        CV_TEST_TAG_LONG,
 +        CV_TEST_TAG_DEBUG_VERYLONG
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Net net = readNetFromCaffe(findDataFile("dnn/rfcn_pascal_voc_resnet50.prototxt"),
 +                               findDataFile("dnn/resnet50_rfcn_final.caffemodel", false));
 +
 +    Mat ref = (Mat_<float>(2, 7) << 0, 7, 0.991359, 491.822, 81.1668, 702.573, 178.234,
 +                                    0, 12, 0.94786, 132.093, 223.903, 338.077, 566.16);
 +
 +    float confThreshold = 0.8, scoreDiff = 0.017, iouDiff = 0.11;
 +    testFaster(net, ref, confThreshold, scoreDiff, iouDiff);
 +}
 +
 +TEST_P(Test_Int8_nets, YoloVoc)
 +{
 +    applyTestTag(
 +#if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL)
 +        CV_TEST_TAG_MEMORY_2GB,
 +#else
 +        CV_TEST_TAG_MEMORY_1GB,
 +#endif
 +        CV_TEST_TAG_LONG
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Mat ref = (Mat_<float>(6, 7) << 0, 6,  0.750469f, 0.577374f, 0.127391f, 0.902949f, 0.300809f,
 +                                    0, 1,  0.780879f, 0.270762f, 0.264102f, 0.732475f, 0.745412f,
 +                                    0, 11, 0.901615f, 0.1386f,   0.338509f, 0.421337f, 0.938789f,
 +                                    1, 14, 0.623813f, 0.183179f, 0.381921f, 0.247726f, 0.625847f,
 +                                    1, 6,  0.667770f, 0.446555f, 0.453578f, 0.499986f, 0.519167f,
 +                                    1, 6,  0.844947f, 0.637058f, 0.460398f, 0.828508f, 0.66427f);
 +
 +    std::string config_file = "yolo-voc.cfg";
 +    std::string weights_file = "yolo-voc.weights";
 +
 +    double scoreDiff = 0.1, iouDiff = 0.3;
 +    {
 +    SCOPED_TRACE("batch size 1");
 +    testDarknetModel(config_file, weights_file, ref.rowRange(0, 3), scoreDiff, iouDiff);
 +    }
 +
 +    {
 +    SCOPED_TRACE("batch size 2");
 +    testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff);
 +    }
 +}
 +
 +TEST_P(Test_Int8_nets, TinyYoloVoc)
 +{
 +    applyTestTag(CV_TEST_TAG_MEMORY_512MB);
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    Mat ref = (Mat_<float>(4, 7) << 0, 6,  0.761967f, 0.579042f, 0.159161f, 0.894482f, 0.31994f,
 +                                    0, 11, 0.780595f, 0.129696f, 0.386467f, 0.445275f, 0.920994f,
 +                                    1, 6,  0.651450f, 0.460526f, 0.458019f, 0.522527f, 0.5341f,
 +                                    1, 6,  0.928758f, 0.651024f, 0.463539f, 0.823784f, 0.654998f);
 +
 +    std::string config_file = "tiny-yolo-voc.cfg";
 +    std::string weights_file = "tiny-yolo-voc.weights";
 +
 +    double scoreDiff = 0.043, iouDiff = 0.12;
 +    {
 +    SCOPED_TRACE("batch size 1");
 +    testDarknetModel(config_file, weights_file, ref.rowRange(0, 2), scoreDiff, iouDiff);
 +    }
 +
 +    {
 +    SCOPED_TRACE("batch size 2");
 +    testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff);
 +    }
 +}
 +
 +TEST_P(Test_Int8_nets, YOLOv3)
 +{
 +    applyTestTag(CV_TEST_TAG_LONG, (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_1GB : CV_TEST_TAG_MEMORY_2GB));
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    const int N0 = 3;
 +    const int N1 = 6;
 +    static const float ref_[/* (N0 + N1) * 7 */] = {
 +0, 16, 0.998836f, 0.160024f, 0.389964f, 0.417885f, 0.943716f,
 +0, 1, 0.987908f, 0.150913f, 0.221933f, 0.742255f, 0.746261f,
 +0, 7, 0.952983f, 0.614621f, 0.150257f, 0.901368f, 0.289251f,
 +
 +1, 2, 0.997412f, 0.647584f, 0.459939f, 0.821037f, 0.663947f,
 +1, 2, 0.989633f, 0.450719f, 0.463353f, 0.496306f, 0.522258f,
 +1, 0, 0.980053f, 0.195856f, 0.378454f, 0.258626f, 0.629257f,
 +1, 9, 0.785341f, 0.665503f, 0.373543f, 0.688893f, 0.439244f,
 +1, 9, 0.733275f, 0.376029f, 0.315694f, 0.401776f, 0.395165f,
 +1, 9, 0.384815f, 0.659824f, 0.372389f, 0.673927f, 0.429412f,
 +    };
 +    Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_);
 +
 +    std::string config_file = "yolov3.cfg";
 +    std::string weights_file = "yolov3.weights";
 +
 +    double scoreDiff = 0.08, iouDiff = 0.21, confThreshold = 0.25;
 +    {
 +        SCOPED_TRACE("batch size 1");
 +        testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff, confThreshold);
 +    }
 +
 +    {
 +        SCOPED_TRACE("batch size 2");
 +        testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, confThreshold);
 +    }
 +}
 +
 +TEST_P(Test_Int8_nets, YOLOv4)
 +{
 +    applyTestTag(CV_TEST_TAG_LONG, (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_1GB : CV_TEST_TAG_MEMORY_2GB));
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    const int N0 = 3;
 +    const int N1 = 7;
 +    static const float ref_[/* (N0 + N1) * 7 */] = {
 +0, 16, 0.992194f, 0.172375f, 0.402458f, 0.403918f, 0.932801f,
 +0, 1, 0.988326f, 0.166708f, 0.228236f, 0.737208f, 0.735803f,
 +0, 7, 0.94639f, 0.602523f, 0.130399f, 0.901623f, 0.298452f,
 +
 +1, 2, 0.99761f, 0.646556f, 0.45985f, 0.816041f, 0.659067f,
 +1, 0, 0.988913f, 0.201726f, 0.360282f, 0.266181f, 0.631728f,
 +1, 2, 0.98233f, 0.452007f, 0.462217f, 0.495612f, 0.521687f,
 +1, 9, 0.919195f, 0.374642f, 0.316524f, 0.398126f, 0.393714f,
 +1, 9, 0.856303f, 0.666842f, 0.372215f, 0.685539f, 0.44141f,
 +1, 9, 0.313516f, 0.656791f, 0.374734f, 0.671959f, 0.438371f,
 +1, 9, 0.256625f, 0.940232f, 0.326931f, 0.967586f, 0.374002f,
 +    };
 +    Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_);
 +
 +    std::string config_file = "yolov4.cfg";
 +    std::string weights_file = "yolov4.weights";
 +    double scoreDiff = 0.15, iouDiff = 0.2;
 +    {
 +        SCOPED_TRACE("batch size 1");
 +        testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff);
 +    }
 +
 +    {
 +        SCOPED_TRACE("batch size 2");
 +
 +        testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff);
 +    }
 +}
 +
 +TEST_P(Test_Int8_nets, YOLOv4_tiny)
 +{
 +    applyTestTag(
 +        target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB
 +    );
 +
 +    if (target == DNN_TARGET_OPENCL_FP16 && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 +    if (target == DNN_TARGET_OPENCL && !ocl::Device::getDefault().isIntel())
 +        applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL);
 +
 +    const float confThreshold = 0.6;
 +
 +    const int N0 = 2;
 +    const int N1 = 3;
 +    static const float ref_[/* (N0 + N1) * 7 */] = {
 +0, 7, 0.85935f, 0.593484f, 0.141211f, 0.920356f, 0.291593f,
 +0, 16, 0.795188f, 0.169207f, 0.386886f, 0.423753f, 0.933004f,
 +
 +1, 2, 0.996832f, 0.653802f, 0.464573f, 0.815193f, 0.653292f,
 +1, 2, 0.963325f, 0.451151f, 0.458915f, 0.496255f, 0.52241f,
 +1, 0, 0.926244f, 0.194851f, 0.361743f, 0.260277f, 0.632364f,
 +    };
 +    Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_);
 +
 +    std::string config_file = "yolov4-tiny.cfg";
 +    std::string weights_file = "yolov4-tiny.weights";
 +    double scoreDiff = 0.12;
 +    double iouDiff = target == DNN_TARGET_OPENCL_FP16 ? 0.2 : 0.082;
 +
 +    {
 +        SCOPED_TRACE("batch size 1");
 +        testDarknetModel(config_file, weights_file, ref.rowRange(0, N0), scoreDiff, iouDiff, confThreshold);
 +    }
 +
 +    throw SkipTestException("batch2: bad accuracy on second image");
 +    /* bad accuracy on second image
 +    {
 +        SCOPED_TRACE("batch size 2");
 +        testDarknetModel(config_file, weights_file, ref, scoreDiff, iouDiff, confThreshold);
 +    }
 +    */
 +}
 +
 +INSTANTIATE_TEST_CASE_P(/**/, Test_Int8_nets, dnnBackendsAndTargetsInt8());
 +
 +}} // namespace

diff --cc modules/dnn/test/test_onnx_importer.cpp
index f222f86,60473ed..50540cd
--- 1/modules/dnn/test/test_onnx_importer.cpp
--- 2/modules/dnn/test/test_onnx_importer.cpp
+++ b/modules/dnn/test/test_onnx_importer.cpp
@@@ -1746,115 -1389,11 +1746,120 @@@ TEST_P(Test_ONNX_layers, DivConst
      testONNXModels("div_const");
  }
  
 +
 +TEST_P(Test_ONNX_layers, Quantized_Convolution)
 +{
 +    testONNXModels("quantized_conv_uint8_weights", npy, 0.004, 0.02);
 +    testONNXModels("quantized_conv_int8_weights", npy, 0.03, 0.5);
 +    testONNXModels("quantized_conv_per_channel_weights", npy, 0.06, 0.4);
 +
 +    testONNXModels("quantized_conv_asymmetric_pads_int8_weights");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_MatMul)
 +{
 +    testONNXModels("quantized_matmul_uint8_weights", npy, 0.005, 0.007);
 +    testONNXModels("quantized_matmul_int8_weights", npy, 0.06, 0.2);
 +    testONNXModels("quantized_matmul_per_channel_weights", npy, 0.06, 0.22);
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_MatMul_Variable_Weights)
 +{
 +    // Unsupported
 +    EXPECT_THROW(
 +    {
 +        testONNXModels("quantized_matmul_variable_inputs");
 +    }, cv::Exception);
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Eltwise)
 +{
 +    testONNXModels("quantized_eltwise");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Eltwise_Scalar)
 +{
 +    testONNXModels("quantized_eltwise_scalar");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Eltwise_Broadcast)
 +{
 +    testONNXModels("quantized_eltwise_broadcast");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_LeakyReLU)
 +{
 +    testONNXModels("quantized_leaky_relu");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Sigmoid)
 +{
 +    testONNXModels("quantized_sigmoid");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_MaxPool)
 +{
 +    testONNXModels("quantized_maxpool");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_AvgPool)
 +{
 +    testONNXModels("quantized_avgpool");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Split)
 +{
 +    testONNXModels("quantized_split");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Pad)
 +{
 +    testONNXModels("quantized_padding");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Reshape)
 +{
 +    testONNXModels("quantized_reshape");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Transpose)
 +{
 +    testONNXModels("quantized_transpose");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Squeeze)
 +{
 +    testONNXModels("quantized_squeeze");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Unsqueeze)
 +{
 +    testONNXModels("quantized_unsqueeze");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Resize)
 +{
 +    testONNXModels("quantized_resize_nearest");
 +    testONNXModels("quantized_resize_bilinear", npy, 2e-4, 0.003);
 +    testONNXModels("quantized_resize_bilinear_align", npy, 3e-4, 0.003);
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Concat)
 +{
 +    testONNXModels("quantized_concat");
 +    testONNXModels("quantized_concat_const_blob");
 +}
 +
 +TEST_P(Test_ONNX_layers, Quantized_Constant)
 +{
 +    testONNXModels("quantized_constant", npy, 0.002, 0.008);
 +}
 +
+ TEST_P(Test_ONNX_layers, OutputRegistration)
+ {
+     testONNXModels("output_registration", npy, 0, 0, false, true, 2);
+ }
+ 
  INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_ONNX_layers, dnnBackendsAndTargets());
  
  class Test_ONNX_nets : public Test_ONNX_layers

diff --cc modules/ts/src/ts_gtest.cpp
Simple merge

diff --cc modules/video/src/tracking/tracker_dasiamrpn.cpp
index 72e0aa1,0000000..debe4e9
mode 100644,000000..100644
--- 1/modules/video/src/tracking/tracker_dasiamrpn.cpp
--- /dev/null
+++ b/modules/video/src/tracking/tracker_dasiamrpn.cpp
@@@ -1,440 -1,0 +1,440 @@@
-     siamRPN.forward(out1, "63");
 +// This file is part of OpenCV project.
 +// It is subject to the license terms in the LICENSE file found in the top-level directory
 +// of this distribution and at http://opencv.org/license.html.
 +
 +#include "../precomp.hpp"
 +
 +#ifdef HAVE_OPENCV_DNN
 +#include "opencv2/dnn.hpp"
 +#endif
 +
 +namespace cv {
 +
 +TrackerDaSiamRPN::TrackerDaSiamRPN()
 +{
 +    // nothing
 +}
 +
 +TrackerDaSiamRPN::~TrackerDaSiamRPN()
 +{
 +    // nothing
 +}
 +
 +TrackerDaSiamRPN::Params::Params()
 +{
 +    model = "dasiamrpn_model.onnx";
 +    kernel_cls1 = "dasiamrpn_kernel_cls1.onnx";
 +    kernel_r1 = "dasiamrpn_kernel_r1.onnx";
 +#ifdef HAVE_OPENCV_DNN
 +    backend = dnn::DNN_BACKEND_DEFAULT;
 +    target = dnn::DNN_TARGET_CPU;
 +#else
 +    backend = -1;  // invalid value
 +    target = -1;  // invalid value
 +#endif
 +}
 +
 +#ifdef HAVE_OPENCV_DNN
 +
 +template <typename T> static
 +T sizeCal(const T& w, const T& h)
 +{
 +    T pad = (w + h) * T(0.5);
 +    T sz2 = (w + pad) * (h + pad);
 +    return sqrt(sz2);
 +}
 +
 +template <>
 +Mat sizeCal(const Mat& w, const Mat& h)
 +{
 +    Mat pad = (w + h) * 0.5;
 +    Mat sz2 = (w + pad).mul((h + pad));
 +
 +    cv::sqrt(sz2, sz2);
 +    return sz2;
 +}
 +
 +class TrackerDaSiamRPNImpl : public TrackerDaSiamRPN
 +{
 +public:
 +    TrackerDaSiamRPNImpl(const TrackerDaSiamRPN::Params& parameters)
 +        : params(parameters)
 +    {
 +
 +        siamRPN = dnn::readNet(params.model);
 +        siamKernelCL1 = dnn::readNet(params.kernel_cls1);
 +        siamKernelR1 = dnn::readNet(params.kernel_r1);
 +
 +        CV_Assert(!siamRPN.empty());
 +        CV_Assert(!siamKernelCL1.empty());
 +        CV_Assert(!siamKernelR1.empty());
 +
 +        siamRPN.setPreferableBackend(params.backend);
 +        siamRPN.setPreferableTarget(params.target);
 +        siamKernelR1.setPreferableBackend(params.backend);
 +        siamKernelR1.setPreferableTarget(params.target);
 +        siamKernelCL1.setPreferableBackend(params.backend);
 +        siamKernelCL1.setPreferableTarget(params.target);
 +    }
 +
 +    void init(InputArray image, const Rect& boundingBox) CV_OVERRIDE;
 +    bool update(InputArray image, Rect& boundingBox) CV_OVERRIDE;
 +    float getTrackingScore() CV_OVERRIDE;
 +
 +    TrackerDaSiamRPN::Params params;
 +
 +protected:
 +    dnn::Net siamRPN, siamKernelR1, siamKernelCL1;
 +    Rect boundingBox_;
 +    Mat image_;
 +    struct trackerConfig
 +    {
 +        float windowInfluence = 0.43f;
 +        float lr = 0.4f;
 +        int scale = 8;
 +        bool swapRB = false;
 +        int totalStride = 8;
 +        float penaltyK = 0.055f;
 +        int exemplarSize = 127;
 +        int instanceSize = 271;
 +        float contextAmount = 0.5f;
 +        std::vector<float> ratios = { 0.33f, 0.5f, 1.0f, 2.0f, 3.0f };
 +        int anchorNum = int(ratios.size());
 +        Mat anchors;
 +        Mat windows;
 +        Scalar avgChans;
 +        Size imgSize = { 0, 0 };
 +        Rect2f targetBox = { 0, 0, 0, 0 };
 +        int scoreSize = (instanceSize - exemplarSize) / totalStride + 1;
 +        float tracking_score;
 +
 +        void update_scoreSize()
 +        {
 +            scoreSize = int((instanceSize - exemplarSize) / totalStride + 1);
 +        }
 +    };
 +    trackerConfig trackState;
 +
 +    void softmax(const Mat& src, Mat& dst);
 +    void elementMax(Mat& src);
 +    Mat generateHanningWindow();
 +    Mat generateAnchors();
 +    Mat getSubwindow(Mat& img, const Rect2f& targetBox, float originalSize, Scalar avgChans);
 +    void trackerInit(Mat img);
 +    void trackerEval(Mat img);
 +};
 +
 +void TrackerDaSiamRPNImpl::init(InputArray image, const Rect& boundingBox)
 +{
 +    image_ = image.getMat().clone();
 +
 +    trackState.update_scoreSize();
 +    trackState.targetBox = Rect2f(
 +        float(boundingBox.x) + float(boundingBox.width) * 0.5f,  // FIXIT don't use center in Rect structures, it is confusing
 +        float(boundingBox.y) + float(boundingBox.height) * 0.5f,
 +        float(boundingBox.width),
 +        float(boundingBox.height)
 +    );
 +    trackerInit(image_);
 +}
 +
 +void TrackerDaSiamRPNImpl::trackerInit(Mat img)
 +{
 +    Rect2f targetBox = trackState.targetBox;
 +    Mat anchors = generateAnchors();
 +    trackState.anchors = anchors;
 +
 +    Mat windows = generateHanningWindow();
 +
 +    trackState.windows = windows;
 +    trackState.imgSize = img.size();
 +
 +    trackState.avgChans = mean(img);
 +    float wc = targetBox.width + trackState.contextAmount * (targetBox.width + targetBox.height);
 +    float hc = targetBox.height + trackState.contextAmount * (targetBox.width + targetBox.height);
 +    float sz = (float)cvRound(sqrt(wc * hc));
 +
 +    Mat zCrop = getSubwindow(img, targetBox, sz, trackState.avgChans);
 +    Mat blob;
 +
 +    dnn::blobFromImage(zCrop, blob, 1.0, Size(trackState.exemplarSize, trackState.exemplarSize), Scalar(), trackState.swapRB, false, CV_32F);
 +    siamRPN.setInput(blob);
 +    Mat out1;
-     siamRPN.setParam(siamRPN.getLayerId("65"), 0, r1.reshape(0, r1_shape));
-     siamRPN.setParam(siamRPN.getLayerId("68"), 0, cls1.reshape(0, cls1_shape));
++    siamRPN.forward(out1, "onnx_node_output_0!63");
 +
 +    siamKernelCL1.setInput(out1);
 +    siamKernelR1.setInput(out1);
 +
 +    Mat cls1 = siamKernelCL1.forward();
 +    Mat r1 = siamKernelR1.forward();
 +    std::vector<int> r1_shape = { 20, 256, 4, 4 }, cls1_shape = { 10, 256, 4, 4 };
 +
++    siamRPN.setParam(siamRPN.getLayerId("onnx_node_output_0!65"), 0, r1.reshape(0, r1_shape));
++    siamRPN.setParam(siamRPN.getLayerId("onnx_node_output_0!68"), 0, cls1.reshape(0, cls1_shape));
 +}
 +
 +bool TrackerDaSiamRPNImpl::update(InputArray image, Rect& boundingBox)
 +{
 +    image_ = image.getMat().clone();
 +    trackerEval(image_);
 +    boundingBox = {
 +        int(trackState.targetBox.x - int(trackState.targetBox.width / 2)),
 +        int(trackState.targetBox.y - int(trackState.targetBox.height / 2)),
 +        int(trackState.targetBox.width),
 +        int(trackState.targetBox.height)
 +    };
 +    return true;
 +}
 +
 +void TrackerDaSiamRPNImpl::trackerEval(Mat img)
 +{
 +    Rect2f targetBox = trackState.targetBox;
 +
 +    float wc = targetBox.height + trackState.contextAmount * (targetBox.width + targetBox.height);
 +    float hc = targetBox.width + trackState.contextAmount * (targetBox.width + targetBox.height);
 +
 +    float sz = sqrt(wc * hc);
 +    float scaleZ = trackState.exemplarSize / sz;
 +
 +    float searchSize = float((trackState.instanceSize - trackState.exemplarSize) / 2);
 +    float pad = searchSize / scaleZ;
 +    float sx = sz + 2 * pad;
 +
 +    Mat xCrop = getSubwindow(img, targetBox, (float)cvRound(sx), trackState.avgChans);
 +
 +    Mat blob;
 +    std::vector<Mat> outs;
 +    std::vector<String> outNames;
 +    Mat delta, score;
 +    Mat sc, rc, penalty, pscore;
 +
 +    dnn::blobFromImage(xCrop, blob, 1.0, Size(trackState.instanceSize, trackState.instanceSize), Scalar(), trackState.swapRB, false, CV_32F);
 +
 +    siamRPN.setInput(blob);
 +
 +    outNames = siamRPN.getUnconnectedOutLayersNames();
 +    siamRPN.forward(outs, outNames);
 +
 +    delta = outs[0];
 +    score = outs[1];
 +
 +    score = score.reshape(0, { 2, trackState.anchorNum, trackState.scoreSize, trackState.scoreSize });
 +    delta = delta.reshape(0, { 4, trackState.anchorNum, trackState.scoreSize, trackState.scoreSize });
 +
 +    softmax(score, score);
 +
 +    targetBox.width *= scaleZ;
 +    targetBox.height *= scaleZ;
 +
 +    score = score.row(1);
 +    score = score.reshape(0, { 5, 19, 19 });
 +
 +    // Post processing
 +    delta.row(0) = delta.row(0).mul(trackState.anchors.row(2)) + trackState.anchors.row(0);
 +    delta.row(1) = delta.row(1).mul(trackState.anchors.row(3)) + trackState.anchors.row(1);
 +    exp(delta.row(2), delta.row(2));
 +    delta.row(2) = delta.row(2).mul(trackState.anchors.row(2));
 +    exp(delta.row(3), delta.row(3));
 +    delta.row(3) = delta.row(3).mul(trackState.anchors.row(3));
 +
 +    sc = sizeCal(delta.row(2), delta.row(3)) / sizeCal(targetBox.width, targetBox.height);
 +    elementMax(sc);
 +
 +    rc = delta.row(2).mul(1 / delta.row(3));
 +    rc = (targetBox.width / targetBox.height) / rc;
 +    elementMax(rc);
 +
 +    // Calculating the penalty
 +    exp(((rc.mul(sc) - 1.) * trackState.penaltyK * (-1.0)), penalty);
 +    penalty = penalty.reshape(0, { trackState.anchorNum, trackState.scoreSize, trackState.scoreSize });
 +
 +    pscore = penalty.mul(score);
 +    pscore = pscore * (1.0 - trackState.windowInfluence) + trackState.windows * trackState.windowInfluence;
 +
 +    int bestID[2] = { 0, 0 };
 +    // Find the index of best score.
 +    minMaxIdx(pscore.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 }), 0, 0, 0, bestID);
 +    delta = delta.reshape(0, { 4, trackState.anchorNum * trackState.scoreSize * trackState.scoreSize });
 +    penalty = penalty.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 });
 +    score = score.reshape(0, { trackState.anchorNum * trackState.scoreSize * trackState.scoreSize, 1 });
 +
 +    int index[2] = { 0, bestID[0] };
 +    Rect2f resBox = { 0, 0, 0, 0 };
 +
 +    resBox.x = delta.at<float>(index) / scaleZ;
 +    index[0] = 1;
 +    resBox.y = delta.at<float>(index) / scaleZ;
 +    index[0] = 2;
 +    resBox.width = delta.at<float>(index) / scaleZ;
 +    index[0] = 3;
 +    resBox.height = delta.at<float>(index) / scaleZ;
 +
 +    float lr = penalty.at<float>(bestID) * score.at<float>(bestID) * trackState.lr;
 +
 +    resBox.x = resBox.x + targetBox.x;
 +    resBox.y = resBox.y + targetBox.y;
 +    targetBox.width /= scaleZ;
 +    targetBox.height /= scaleZ;
 +
 +    resBox.width = targetBox.width * (1 - lr) + resBox.width * lr;
 +    resBox.height = targetBox.height * (1 - lr) + resBox.height * lr;
 +
 +    resBox.x = float(fmax(0., fmin(float(trackState.imgSize.width), resBox.x)));
 +    resBox.y = float(fmax(0., fmin(float(trackState.imgSize.height), resBox.y)));
 +    resBox.width = float(fmax(10., fmin(float(trackState.imgSize.width), resBox.width)));
 +    resBox.height = float(fmax(10., fmin(float(trackState.imgSize.height), resBox.height)));
 +
 +    trackState.targetBox = resBox;
 +    trackState.tracking_score = score.at<float>(bestID);
 +}
 +
 +float TrackerDaSiamRPNImpl::getTrackingScore()
 +{
 +    return trackState.tracking_score;
 +}
 +
 +void TrackerDaSiamRPNImpl::softmax(const Mat& src, Mat& dst)
 +{
 +    Mat maxVal;
 +    cv::max(src.row(1), src.row(0), maxVal);
 +
 +    src.row(1) -= maxVal;
 +    src.row(0) -= maxVal;
 +
 +    exp(src, dst);
 +
 +    Mat sumVal = dst.row(0) + dst.row(1);
 +    dst.row(0) = dst.row(0) / sumVal;
 +    dst.row(1) = dst.row(1) / sumVal;
 +}
 +
 +void TrackerDaSiamRPNImpl::elementMax(Mat& src)
 +{
 +    int* p = src.size.p;
 +    int index[4] = { 0, 0, 0, 0 };
 +    for (int n = 0; n < *p; n++)
 +    {
 +        for (int k = 0; k < *(p + 1); k++)
 +        {
 +            for (int i = 0; i < *(p + 2); i++)
 +            {
 +                for (int j = 0; j < *(p + 3); j++)
 +                {
 +                    index[0] = n, index[1] = k, index[2] = i, index[3] = j;
 +                    float& v = src.at<float>(index);
 +                    v = fmax(v, 1.0f / v);
 +                }
 +            }
 +        }
 +    }
 +}
 +
 +Mat TrackerDaSiamRPNImpl::generateHanningWindow()
 +{
 +    Mat baseWindows, HanningWindows;
 +
 +    createHanningWindow(baseWindows, Size(trackState.scoreSize, trackState.scoreSize), CV_32F);
 +    baseWindows = baseWindows.reshape(0, { 1, trackState.scoreSize, trackState.scoreSize });
 +    HanningWindows = baseWindows.clone();
 +    for (int i = 1; i < trackState.anchorNum; i++)
 +    {
 +        HanningWindows.push_back(baseWindows);
 +    }
 +
 +    return HanningWindows;
 +}
 +
 +Mat TrackerDaSiamRPNImpl::generateAnchors()
 +{
 +    int totalStride = trackState.totalStride, scales = trackState.scale, scoreSize = trackState.scoreSize;
 +    std::vector<float> ratios = trackState.ratios;
 +    std::vector<Rect2f> baseAnchors;
 +    int anchorNum = int(ratios.size());
 +    int size = totalStride * totalStride;
 +
 +    float ori = -(float(scoreSize / 2)) * float(totalStride);
 +
 +    for (auto i = 0; i < anchorNum; i++)
 +    {
 +        int ws = int(sqrt(size / ratios[i]));
 +        int hs = int(ws * ratios[i]);
 +
 +        float wws = float(ws) * scales;
 +        float hhs = float(hs) * scales;
 +        Rect2f anchor = { 0, 0, wws, hhs };
 +        baseAnchors.push_back(anchor);
 +    }
 +
 +    int anchorIndex[4] = { 0, 0, 0, 0 };
 +    const int sizes[4] = { 4, (int)ratios.size(), scoreSize, scoreSize };
 +    Mat anchors(4, sizes, CV_32F);
 +
 +    for (auto i = 0; i < scoreSize; i++)
 +    {
 +        for (auto j = 0; j < scoreSize; j++)
 +        {
 +            for (auto k = 0; k < anchorNum; k++)
 +            {
 +                anchorIndex[0] = 1, anchorIndex[1] = k, anchorIndex[2] = i, anchorIndex[3] = j;
 +                anchors.at<float>(anchorIndex) = ori + totalStride * i;
 +
 +                anchorIndex[0] = 0;
 +                anchors.at<float>(anchorIndex) = ori + totalStride * j;
 +
 +                anchorIndex[0] = 2;
 +                anchors.at<float>(anchorIndex) = baseAnchors[k].width;
 +
 +                anchorIndex[0] = 3;
 +                anchors.at<float>(anchorIndex) = baseAnchors[k].height;
 +            }
 +        }
 +    }
 +
 +    return anchors;
 +}
 +
 +Mat TrackerDaSiamRPNImpl::getSubwindow(Mat& img, const Rect2f& targetBox, float originalSize, Scalar avgChans)
 +{
 +    Mat zCrop, dst;
 +    Size imgSize = img.size();
 +    float c = (originalSize + 1) / 2;
 +    float xMin = (float)cvRound(targetBox.x - c);
 +    float xMax = xMin + originalSize - 1;
 +    float yMin = (float)cvRound(targetBox.y - c);
 +    float yMax = yMin + originalSize - 1;
 +
 +    int leftPad = (int)(fmax(0., -xMin));
 +    int topPad = (int)(fmax(0., -yMin));
 +    int rightPad = (int)(fmax(0., xMax - imgSize.width + 1));
 +    int bottomPad = (int)(fmax(0., yMax - imgSize.height + 1));
 +
 +    xMin = xMin + leftPad;
 +    xMax = xMax + leftPad;
 +    yMax = yMax + topPad;
 +    yMin = yMin + topPad;
 +
 +    if (topPad == 0 && bottomPad == 0 && leftPad == 0 && rightPad == 0)
 +    {
 +        img(Rect(int(xMin), int(yMin), int(xMax - xMin + 1), int(yMax - yMin + 1))).copyTo(zCrop);
 +    }
 +    else
 +    {
 +        copyMakeBorder(img, dst, topPad, bottomPad, leftPad, rightPad, BORDER_CONSTANT, avgChans);
 +        dst(Rect(int(xMin), int(yMin), int(xMax - xMin + 1), int(yMax - yMin + 1))).copyTo(zCrop);
 +    }
 +
 +    return zCrop;
 +}
 +Ptr<TrackerDaSiamRPN> TrackerDaSiamRPN::create(const TrackerDaSiamRPN::Params& parameters)
 +{
 +    return makePtr<TrackerDaSiamRPNImpl>(parameters);
 +}
 +
 +#else  // OPENCV_HAVE_DNN
 +Ptr<TrackerDaSiamRPN> TrackerDaSiamRPN::create(const TrackerDaSiamRPN::Params& parameters)
 +{
 +    (void)(parameters);
 +    CV_Error(cv::Error::StsNotImplemented, "to use GOTURN, the tracking module needs to be built with opencv_dnn !");
 +}
 +#endif  // OPENCV_HAVE_DNN
 +}