dnn: move module from opencv_contrib

https://github.com/opencv/opencv_contrib/tree/e6f63c7a38ca40c5dc33e38736e3027e3528d6cb/modules/dnn

modules/dnn/test/cityscapes_semsegm_test_enet.py

@@ -0,0 +1,142 @@
+import numpy as np
+import sys
+import os
+import fnmatch
+import argparse
+
+# sys.path.append('<path to opencv_build_dir/lib>')
+sys.path.append('/home/arrybn/build/opencv_w_contrib/lib')
+try:
+    import cv2 as cv
+except ImportError:
+    raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to opencv_build_dir/lib dir')
+try:
+    import torch
+except ImportError:
+    raise ImportError('Can\'t find pytorch. Please intall it by following instructions on the official site')
+
+from torch.utils.serialization import load_lua
+from pascal_semsegm_test_fcn import eval_segm_result, get_conf_mat, get_metrics, DatasetImageFetch, SemSegmEvaluation
+from imagenet_cls_test_alexnet import Framework, DnnCaffeModel
+
+
+class NormalizePreproc:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def process(img):
+        image_data = np.array(img).transpose(2, 0, 1).astype(np.float32)
+        image_data = np.expand_dims(image_data, 0)
+        image_data /= 255.0
+        return image_data
+
+
+class CityscapesDataFetch(DatasetImageFetch):
+    img_dir = ''
+    segm_dir = ''
+    segm_files = []
+    colors = []
+    i = 0
+
+    def __init__(self, img_dir, segm_dir, preproc):
+        self.img_dir = img_dir
+        self.segm_dir = segm_dir
+        self.segm_files = sorted([img for img in self.locate('*_color.png', segm_dir)])
+        self.colors = self.get_colors()
+        self.data_prepoc = preproc
+        self.i = 0
+
+    @staticmethod
+    def get_colors():
+        result = []
+        colors_list = (
+         (0, 0, 0), (128, 64, 128), (244, 35, 232), (70, 70, 70), (102, 102, 156), (190, 153, 153), (153, 153, 153),
+         (250, 170, 30), (220, 220, 0), (107, 142, 35), (152, 251, 152), (70, 130, 180), (220, 20, 60), (255, 0, 0),
+         (0, 0, 142), (0, 0, 70), (0, 60, 100), (0, 80, 100), (0, 0, 230), (119, 11, 32))
+
+        for c in colors_list:
+            result.append(DatasetImageFetch.pix_to_c(c))
+        return result
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        if self.i < len(self.segm_files):
+            segm_file = self.segm_files[self.i]
+            segm = cv.imread(segm_file, cv.IMREAD_COLOR)[:, :, ::-1]
+            segm = cv.resize(segm, (1024, 512), interpolation=cv.INTER_NEAREST)
+
+            img_file = self.rreplace(self.img_dir + segm_file[len(self.segm_dir):], 'gtFine_color', 'leftImg8bit')
+            assert os.path.exists(img_file)
+            img = cv.imread(img_file, cv.IMREAD_COLOR)[:, :, ::-1]
+            img = cv.resize(img, (1024, 512))
+
+            self.i += 1
+            gt = self.color_to_gt(segm, self.colors)
+            img = self.data_prepoc.process(img)
+            return img, gt
+        else:
+            self.i = 0
+            raise StopIteration
+
+    def get_num_classes(self):
+        return len(self.colors)
+
+    @staticmethod
+    def locate(pattern, root_path):
+        for path, dirs, files in os.walk(os.path.abspath(root_path)):
+            for filename in fnmatch.filter(files, pattern):
+                yield os.path.join(path, filename)
+
+    @staticmethod
+    def rreplace(s, old, new, occurrence=1):
+        li = s.rsplit(old, occurrence)
+        return new.join(li)
+
+
+class TorchModel(Framework):
+    net = object
+
+    def __init__(self, model_file):
+        self.net = load_lua(model_file)
+
+    def get_name(self):
+        return 'Torch'
+
+    def get_output(self, input_blob):
+        tensor = torch.FloatTensor(input_blob)
+        out = self.net.forward(tensor).numpy()
+        return out
+
+
+class DnnTorchModel(DnnCaffeModel):
+    net = cv.dnn.Net()
+
+    def __init__(self, model_file):
+        self.net = cv.dnn.readNetFromTorch(model_file)
+
+    def get_output(self, input_blob):
+        self.net.setBlob("", input_blob)
+        self.net.forward()
+        return self.net.getBlob(self.net.getLayerNames()[-1])
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--imgs_dir", help="path to Cityscapes validation images dir, imgsfine/leftImg8bit/val")
+    parser.add_argument("--segm_dir", help="path to Cityscapes dir with segmentation, gtfine/gtFine/val")
+    parser.add_argument("--model", help="path to torch model, download it here: "
+                        "https://www.dropbox.com/sh/dywzk3gyb12hpe5/AAD5YkUa8XgMpHs2gCRgmCVCa")
+    parser.add_argument("--log", help="path to logging file")
+    args = parser.parse_args()
+
+    prep = NormalizePreproc()
+    df = CityscapesDataFetch(args.imgs_dir, args.segm_dir, prep)
+
+    fw = [TorchModel(args.model),
+          DnnTorchModel(args.model)]
+
+    segm_eval = SemSegmEvaluation(args.log)
+    segm_eval.process(fw, df)

modules/dnn/test/cnpy.cpp

@@ -0,0 +1,291 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//Copyright (C) 2011  Carl Rogers
+//Released under MIT License
+//license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php
+
+#include"cnpy.h"
+#include<complex>
+#include<cstdlib>
+#include<algorithm>
+#include<cstring>
+#include<iomanip>
+
+char cnpy::BigEndianTest() {
+    union
+    {
+        unsigned char x[2];
+        short y;
+    };
+    x[0] = 1;
+    x[1] = 0;
+
+    return y == 1 ? '<' : '>';
+}
+
+char cnpy::map_type(const std::type_info& t)
+{
+    if(t == typeid(float) ) return 'f';
+    if(t == typeid(double) ) return 'f';
+    if(t == typeid(long double) ) return 'f';
+
+    if(t == typeid(int) ) return 'i';
+    if(t == typeid(char) ) return 'i';
+    if(t == typeid(short) ) return 'i';
+    if(t == typeid(long) ) return 'i';
+    if(t == typeid(long long) ) return 'i';
+
+    if(t == typeid(unsigned char) ) return 'u';
+    if(t == typeid(unsigned short) ) return 'u';
+    if(t == typeid(unsigned long) ) return 'u';
+    if(t == typeid(unsigned long long) ) return 'u';
+    if(t == typeid(unsigned int) ) return 'u';
+
+    if(t == typeid(bool) ) return 'b';
+
+    if(t == typeid(std::complex<float>) ) return 'c';
+    if(t == typeid(std::complex<double>) ) return 'c';
+    if(t == typeid(std::complex<long double>) ) return 'c';
+
+    else return '?';
+}
+
+template<> std::vector<char>& cnpy::operator+=(std::vector<char>& lhs, const std::string rhs) {
+    lhs.insert(lhs.end(),rhs.begin(),rhs.end());
+    return lhs;
+}
+
+template<> std::vector<char>& cnpy::operator+=(std::vector<char>& lhs, const char* rhs) {
+    //write in little endian
+    size_t len = strlen(rhs);
+    lhs.reserve(len);
+    for(size_t byte = 0; byte < len; byte++) {
+        lhs.push_back(rhs[byte]);
+    }
+    return lhs;
+}
+
+void cnpy::parse_npy_header(FILE* fp, unsigned int& word_size, unsigned int*& shape, unsigned int& ndims, bool& fortran_order) {
+    char buffer[256];
+    size_t res = fread(buffer,sizeof(char),11,fp);
+    if(res != 11)
+        throw std::runtime_error("parse_npy_header: failed fread");
+    std::string header = fgets(buffer,256,fp);
+    cnpy_assert(header[header.size()-1] == '\n');
+
+    size_t loc1, loc2;
+
+    //fortran order
+    loc1 = header.find("fortran_order")+16;
+    fortran_order = (header.substr(loc1,5) == "True" ? true : false);
+
+    //shape
+    loc1 = header.find("(");
+    loc2 = header.find(")");
+    std::string str_shape = header.substr(loc1+1,loc2-loc1-1);
+    if(str_shape[str_shape.size()-1] == ',') ndims = 1;
+    else ndims = (unsigned)std::count(str_shape.begin(),str_shape.end(),',')+1;
+    shape = new unsigned int[ndims];
+    for(unsigned int i = 0;i < ndims;i++) {
+        loc1 = str_shape.find(",");
+        shape[i] = atoi(str_shape.substr(0,loc1).c_str());
+        str_shape = str_shape.substr(loc1+1);
+    }
+
+    //endian, word size, data type
+    //byte order code | stands for not applicable.
+    //not sure when this applies except for byte array
+    loc1 = header.find("descr")+9;
+    bool littleEndian = (header[loc1] == '<' || header[loc1] == '|' ? true : false);
+    cnpy_assert(littleEndian);
+
+    //char type = header[loc1+1];
+    //assert(type == map_type(T));
+
+    std::string str_ws = header.substr(loc1+2);
+    loc2 = str_ws.find("'");
+    word_size = atoi(str_ws.substr(0,loc2).c_str());
+}
+
+void cnpy::parse_zip_footer(FILE* fp, unsigned short& nrecs, unsigned int& global_header_size, unsigned int& global_header_offset)
+{
+    std::vector<char> footer(22);
+    fseek(fp,-22,SEEK_END);
+    size_t res = fread(&footer[0],sizeof(char),22,fp);
+    if(res != 22)
+        throw std::runtime_error("parse_zip_footer: failed fread");
+
+    unsigned short disk_no, disk_start, nrecs_on_disk, comment_len;
+    disk_no = *(unsigned short*) &footer[4];
+    disk_start = *(unsigned short*) &footer[6];
+    nrecs_on_disk = *(unsigned short*) &footer[8];
+    nrecs = *(unsigned short*) &footer[10];
+    global_header_size = *(unsigned int*) &footer[12];
+    global_header_offset = *(unsigned int*) &footer[16];
+    comment_len = *(unsigned short*) &footer[20];
+
+    cnpy_assert(disk_no == 0);
+    cnpy_assert(disk_start == 0);
+    cnpy_assert(nrecs_on_disk == nrecs);
+    cnpy_assert(comment_len == 0);
+}
+
+cnpy::NpyArray load_the_npy_file(FILE* fp) {
+    unsigned int* shape;
+    unsigned int ndims, word_size;
+    bool fortran_order;
+    cnpy::parse_npy_header(fp,word_size,shape,ndims,fortran_order);
+    unsigned long long size = 1; //long long so no overflow when multiplying by word_size
+    for(unsigned int i = 0;i < ndims;i++) size *= shape[i];
+
+    cnpy::NpyArray arr;
+    arr.word_size = word_size;
+    arr.shape = std::vector<unsigned int>(shape,shape+ndims);
+    delete[] shape;
+    arr.data = new char[size*word_size];
+    arr.fortran_order = fortran_order;
+    size_t nread = fread(arr.data,word_size,size,fp);
+    if(nread != size)
+        throw std::runtime_error("load_the_npy_file: failed fread");
+    return arr;
+}
+
+cnpy::npz_t cnpy::npz_load(std::string fname) {
+    FILE* fp = fopen(fname.c_str(),"rb");
+
+    if(!fp) printf("npz_load: Error! Unable to open file %s!\n",fname.c_str());
+    cnpy_assert(fp);
+
+    cnpy::npz_t arrays;
+
+    while(1) {
+        std::vector<char> local_header(30);
+        size_t headerres = fread(&local_header[0],sizeof(char),30,fp);
+        if(headerres != 30)
+            throw std::runtime_error("npz_load: failed fread");
+
+        //if we've reached the global header, stop reading
+        if(local_header[2] != 0x03 || local_header[3] != 0x04) break;
+
+        //read in the variable name
+        unsigned short name_len = *(unsigned short*) &local_header[26];
+        std::string varname(name_len,' ');
+        size_t vname_res = fread(&varname[0],sizeof(char),name_len,fp);
+        if(vname_res != name_len)
+            throw std::runtime_error("npz_load: failed fread");
+
+        //erase the lagging .npy
+        varname.erase(varname.end()-4,varname.end());
+
+        //read in the extra field
+        unsigned short extra_field_len = *(unsigned short*) &local_header[28];
+        if(extra_field_len > 0) {
+            std::vector<char> buff(extra_field_len);
+            size_t efield_res = fread(&buff[0],sizeof(char),extra_field_len,fp);
+            if(efield_res != extra_field_len)
+                throw std::runtime_error("npz_load: failed fread");
+        }
+
+        arrays[varname] = load_the_npy_file(fp);
+    }
+
+    fclose(fp);
+    return arrays;
+}
+
+cnpy::NpyArray cnpy::npz_load(std::string fname, std::string varname) {
+    FILE* fp = fopen(fname.c_str(),"rb");
+
+    if(!fp) {
+        throw std::runtime_error("npz_load: Error! Unable to open file " + fname + "!\n");
+    }
+
+    while(1) {
+        std::vector<char> local_header(30);
+        size_t header_res = fread(&local_header[0],sizeof(char),30,fp);
+        if(header_res != 30)
+            throw std::runtime_error("npz_load: failed fread");
+
+        //if we've reached the global header, stop reading
+        if(local_header[2] != 0x03 || local_header[3] != 0x04) break;
+
+        //read in the variable name
+        unsigned short name_len = *(unsigned short*) &local_header[26];
+        std::string vname(name_len,' ');
+        size_t vname_res = fread(&vname[0],sizeof(char),name_len,fp);
+        if(vname_res != name_len)
+            throw std::runtime_error("npz_load: failed fread");
+        vname.erase(vname.end()-4,vname.end()); //erase the lagging .npy
+
+        //read in the extra field
+        unsigned short extra_field_len = *(unsigned short*) &local_header[28];
+        fseek(fp,extra_field_len,SEEK_CUR); //skip past the extra field
+
+        if(vname == varname) {
+            NpyArray array = load_the_npy_file(fp);
+            fclose(fp);
+            return array;
+        }
+        else {
+            //skip past the data
+            unsigned int size = *(unsigned int*) &local_header[22];
+            fseek(fp,size,SEEK_CUR);
+        }
+    }
+
+    fclose(fp);
+    throw std::runtime_error("npz_load: Error! Variable name " + varname + " not found in " + fname + "!\n");
+}
+
+cnpy::NpyArray cnpy::npy_load(std::string fname) {
+
+    FILE* fp = fopen(fname.c_str(), "rb");
+
+    if(!fp) {
+        throw std::runtime_error("npy_load: Error! Unable to open file " + fname + "!\n");
+    }
+
+    NpyArray arr = load_the_npy_file(fp);
+
+    fclose(fp);
+    return arr;
+}

modules/dnn/test/cnpy.h

@@ -0,0 +1,294 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+//Copyright (C) 2011  Carl Rogers
+//Released under MIT License
+//license available in LICENSE file, or at http://www.opensource.org/licenses/mit-license.php
+
+#ifndef LIBCNPY_H_
+#define LIBCNPY_H_
+
+#include<string>
+#include<stdexcept>
+#include<sstream>
+#include<vector>
+#include<cstdio>
+#include<typeinfo>
+#include<iostream>
+#include<cassert>
+#include<map>
+#if defined(HAVE_ZLIB) && HAVE_ZLIB
+#include<zlib.h>
+#endif
+
+#ifndef NDEBUG
+#define cnpy_assert(expression) assert(expression)
+#else
+#define cnpy_assert(expression) ((void)(expression))
+#endif
+
+namespace cnpy {
+
+    struct NpyArray {
+        char* data;
+        std::vector<unsigned int> shape;
+        unsigned int word_size;
+        bool fortran_order;
+        void destruct() {delete[] data;}
+    };
+
+    struct npz_t : public std::map<std::string, NpyArray>
+    {
+        void destruct()
+        {
+            npz_t::iterator it = this->begin();
+            for(; it != this->end(); ++it) (*it).second.destruct();
+        }
+    };
+
+    char BigEndianTest();
+    char map_type(const std::type_info& t);
+    template<typename T> std::vector<char> create_npy_header(const T* data, const unsigned int* shape, const unsigned int ndims);
+    void parse_npy_header(FILE* fp,unsigned int& word_size, unsigned int*& shape, unsigned int& ndims, bool& fortran_order);
+    void parse_zip_footer(FILE* fp, unsigned short& nrecs, unsigned int& global_header_size, unsigned int& global_header_offset);
+    npz_t npz_load(std::string fname);
+    NpyArray npz_load(std::string fname, std::string varname);
+    NpyArray npy_load(std::string fname);
+
+    template<typename T> std::vector<char>& operator+=(std::vector<char>& lhs, const T rhs) {
+        //write in little endian
+        for(char byte = 0; (size_t)byte < sizeof(T); byte++) {
+            char val = *((char*)&rhs+byte);
+            lhs.push_back(val);
+        }
+        return lhs;
+    }
+
+    template<> std::vector<char>& operator+=(std::vector<char>& lhs, const std::string rhs);
+    template<> std::vector<char>& operator+=(std::vector<char>& lhs, const char* rhs);
+
+
+    template<typename T> std::string tostring(T i, int = 0, char = ' ') {
+        std::stringstream s;
+        s << i;
+        return s.str();
+    }
+
+    template<typename T> void npy_save(std::string fname, const T* data, const unsigned int* shape, const unsigned int ndims, std::string mode = "w") {
+        FILE* fp = NULL;
+
+        if(mode == "a") fp = fopen(fname.c_str(),"r+b");
+
+        if(fp) {
+            //file exists. we need to append to it. read the header, modify the array size
+            unsigned int word_size, tmp_dims;
+            unsigned int* tmp_shape = 0;
+            bool fortran_order;
+            parse_npy_header(fp,word_size,tmp_shape,tmp_dims,fortran_order);
+            cnpy_assert(!fortran_order);
+
+            if(word_size != sizeof(T)) {
+                std::cout<<"libnpy error: "<<fname<<" has word size "<<word_size<<" but npy_save appending data sized "<<sizeof(T)<<"\n";
+                cnpy_assert( word_size == sizeof(T) );
+            }
+            if(tmp_dims != ndims) {
+                std::cout<<"libnpy error: npy_save attempting to append misdimensioned data to "<<fname<<"\n";
+                cnpy_assert(tmp_dims == ndims);
+            }
+
+            for(unsigned i = 1; i < ndims; i++) {
+                if(shape[i] != tmp_shape[i]) {
+                    std::cout<<"libnpy error: npy_save attempting to append misshaped data to "<<fname<<"\n";
+                    cnpy_assert(shape[i] == tmp_shape[i]);
+                }
+            }
+            tmp_shape[0] += shape[0];
+
+            fseek(fp,0,SEEK_SET);
+            std::vector<char> header = create_npy_header(data,tmp_shape,ndims);
+            fwrite(&header[0],sizeof(char),header.size(),fp);
+            fseek(fp,0,SEEK_END);
+
+            delete[] tmp_shape;
+        }
+        else {
+            fp = fopen(fname.c_str(),"wb");
+            std::vector<char> header = create_npy_header(data,shape,ndims);
+            fwrite(&header[0],sizeof(char),header.size(),fp);
+        }
+
+        unsigned int nels = 1;
+        for(unsigned i = 0;i < ndims;i++) nels *= shape[i];
+
+        fwrite(data,sizeof(T),nels,fp);
+        fclose(fp);
+    }
+
+    template<typename T> void npz_save(std::string zipname, std::string fname, const T* data, const unsigned int* shape, const unsigned int ndims, std::string mode = "w")
+    {
+        //first, append a .npy to the fname
+        fname += ".npy";
+
+        //now, on with the show
+        FILE* fp = NULL;
+        unsigned short nrecs = 0;
+        unsigned int global_header_offset = 0;
+        std::vector<char> global_header;
+
+        if(mode == "a") fp = fopen(zipname.c_str(),"r+b");
+
+        if(fp) {
+            //zip file exists. we need to add a new npy file to it.
+            //first read the footer. this gives us the offset and size of the global header
+            //then read and store the global header.
+            //below, we will write the the new data at the start of the global header then append the global header and footer below it
+            unsigned int global_header_size;
+            parse_zip_footer(fp,nrecs,global_header_size,global_header_offset);
+            fseek(fp,global_header_offset,SEEK_SET);
+            global_header.resize(global_header_size);
+            size_t res = fread(&global_header[0],sizeof(char),global_header_size,fp);
+            if(res != global_header_size){
+                throw std::runtime_error("npz_save: header read error while adding to existing zip");
+            }
+            fseek(fp,global_header_offset,SEEK_SET);
+        }
+        else {
+            fp = fopen(zipname.c_str(),"wb");
+        }
+
+        std::vector<char> npy_header = create_npy_header(data,shape,ndims);
+
+        unsigned long nels = 1;
+        for (unsigned m=0; m<ndims; m++ ) nels *= shape[m];
+        int nbytes = nels*sizeof(T) + npy_header.size();
+
+        //get the CRC of the data to be added
+        #if defined(HAVE_ZLIB) && HAVE_ZLIB
+        unsigned int crc = crc32(0L,(unsigned char*)&npy_header[0],npy_header.size());
+        crc = crc32(crc,(unsigned char*)data,nels*sizeof(T));
+        #else
+        unsigned int crc = 0;
+        #endif
+
+        //build the local header
+        std::vector<char> local_header;
+        local_header += "PK"; //first part of sig
+        local_header += (unsigned short) 0x0403; //second part of sig
+        local_header += (unsigned short) 20; //min version to extract
+        local_header += (unsigned short) 0; //general purpose bit flag
+        local_header += (unsigned short) 0; //compression method
+        local_header += (unsigned short) 0; //file last mod time
+        local_header += (unsigned short) 0;     //file last mod date
+        local_header += (unsigned int) crc; //crc
+        local_header += (unsigned int) nbytes; //compressed size
+        local_header += (unsigned int) nbytes; //uncompressed size
+        local_header += (unsigned short) fname.size(); //fname length
+        local_header += (unsigned short) 0; //extra field length
+        local_header += fname;
+
+        //build global header
+        global_header += "PK"; //first part of sig
+        global_header += (unsigned short) 0x0201; //second part of sig
+        global_header += (unsigned short) 20; //version made by
+        global_header.insert(global_header.end(),local_header.begin()+4,local_header.begin()+30);
+        global_header += (unsigned short) 0; //file comment length
+        global_header += (unsigned short) 0; //disk number where file starts
+        global_header += (unsigned short) 0; //internal file attributes
+        global_header += (unsigned int) 0; //external file attributes
+        global_header += (unsigned int) global_header_offset; //relative offset of local file header, since it begins where the global header used to begin
+        global_header += fname;
+
+        //build footer
+        std::vector<char> footer;
+        footer += "PK"; //first part of sig
+        footer += (unsigned short) 0x0605; //second part of sig
+        footer += (unsigned short) 0; //number of this disk
+        footer += (unsigned short) 0; //disk where footer starts
+        footer += (unsigned short) (nrecs+1); //number of records on this disk
+        footer += (unsigned short) (nrecs+1); //total number of records
+        footer += (unsigned int) global_header.size(); //nbytes of global headers
+        footer += (unsigned int) (global_header_offset + nbytes + local_header.size()); //offset of start of global headers, since global header now starts after newly written array
+        footer += (unsigned short) 0; //zip file comment length
+
+        //write everything
+        fwrite(&local_header[0],sizeof(char),local_header.size(),fp);
+        fwrite(&npy_header[0],sizeof(char),npy_header.size(),fp);
+        fwrite(data,sizeof(T),nels,fp);
+        fwrite(&global_header[0],sizeof(char),global_header.size(),fp);
+        fwrite(&footer[0],sizeof(char),footer.size(),fp);
+        fclose(fp);
+    }
+
+    template<typename T> std::vector<char> create_npy_header(const T*, const unsigned int* shape, const unsigned int ndims) {
+
+        std::vector<char> dict;
+        dict += "{'descr': '";
+        dict += BigEndianTest();
+        dict += map_type(typeid(T));
+        dict += tostring(sizeof(T));
+        dict += "', 'fortran_order': False, 'shape': (";
+        dict += tostring(shape[0]);
+        for(unsigned i = 1;i < ndims;i++) {
+            dict += ", ";
+            dict += tostring(shape[i]);
+        }
+        if(ndims == 1) dict += ",";
+        dict += "), }";
+        //pad with spaces so that preamble+dict is modulo 16 bytes. preamble is 10 bytes. dict needs to end with \n
+        int remainder = 16 - (10 + dict.size()) % 16;
+        dict.insert(dict.end(),remainder,' ');
+        dict.back() = '\n';
+
+        std::vector<char> header;
+        header += (unsigned char) 0x93;
+        header += "NUMPY";
+        header += (char) 0x01; //major version of numpy format
+        header += (char) 0x00; //minor version of numpy format
+        header += (unsigned short) dict.size();
+        header.insert(header.end(),dict.begin(),dict.end());
+
+        return header;
+    }
+
+
+}
+
+#endif

modules/dnn/test/imagenet_cls_test_alexnet.py

@@ -0,0 +1,246 @@
+from abc import ABCMeta, abstractmethod
+import numpy as np
+import sys
+import os
+import argparse
+import time
+
+# sys.path.append('<path to git/caffe/python dir>')
+sys.path.append('/home/arrybn/git/caffe/python')
+try:
+    import caffe
+except ImportError:
+    raise ImportError('Can\'t find caffe. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to git/caffe/python dir')
+# sys.path.append('<path to opencv_build_dir/lib>')
+sys.path.append('/home/arrybn/build/opencv_w_contrib/lib')
+try:
+    import cv2 as cv
+except ImportError:
+    raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to opencv_build_dir/lib dir')
+
+
+class DataFetch(object):
+    imgs_dir = ''
+    frame_size = 0
+    bgr_to_rgb = False
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def preprocess(self, img):
+        pass
+
+    def get_batch(self, imgs_names):
+        assert type(imgs_names) is list
+        batch = np.zeros((len(imgs_names), 3, self.frame_size, self.frame_size)).astype(np.float32)
+        for i in range(len(imgs_names)):
+            img_name = imgs_names[i]
+            img_file = self.imgs_dir + img_name
+            assert os.path.exists(img_file)
+            img = cv.imread(img_file, cv.IMREAD_COLOR)
+            min_dim = min(img.shape[-3], img.shape[-2])
+            resize_ratio = self.frame_size / float(min_dim)
+            img = cv.resize(img, (0, 0), fx=resize_ratio, fy=resize_ratio)
+            cols = img.shape[1]
+            rows = img.shape[0]
+            y1 = (rows - self.frame_size) / 2
+            y2 = y1 + self.frame_size
+            x1 = (cols - self.frame_size) / 2
+            x2 = x1 + self.frame_size
+            img = img[y1:y2, x1:x2]
+            if self.bgr_to_rgb:
+                img = img[..., ::-1]
+            image_data = img[:, :, 0:3].transpose(2, 0, 1)
+            batch[i] = self.preprocess(image_data)
+        return batch
+
+
+class MeanBlobFetch(DataFetch):
+    mean_blob = np.ndarray(())
+
+    def __init__(self, frame_size, mean_blob_path, imgs_dir):
+        self.imgs_dir = imgs_dir
+        self.frame_size = frame_size
+        blob = caffe.proto.caffe_pb2.BlobProto()
+        data = open(mean_blob_path, 'rb').read()
+        blob.ParseFromString(data)
+        self.mean_blob = np.array(caffe.io.blobproto_to_array(blob))
+        start = (self.mean_blob.shape[2] - self.frame_size) / 2
+        stop = start + self.frame_size
+        self.mean_blob = self.mean_blob[:, :, start:stop, start:stop][0]
+
+    def preprocess(self, img):
+        return img - self.mean_blob
+
+
+class MeanChannelsFetch(MeanBlobFetch):
+    def __init__(self, frame_size, imgs_dir):
+        self.imgs_dir = imgs_dir
+        self.frame_size = frame_size
+        self.mean_blob = np.ones((3, self.frame_size, self.frame_size)).astype(np.float32)
+        self.mean_blob[0] *= 104
+        self.mean_blob[1] *= 117
+        self.mean_blob[2] *= 123
+
+
+class MeanValueFetch(MeanBlobFetch):
+    def __init__(self, frame_size, imgs_dir, bgr_to_rgb):
+        self.imgs_dir = imgs_dir
+        self.frame_size = frame_size
+        self.mean_blob = np.ones((3, self.frame_size, self.frame_size)).astype(np.float32)
+        self.mean_blob *= 117
+        self.bgr_to_rgb = bgr_to_rgb
+
+
+def get_correct_answers(img_list, img_classes, net_output_blob):
+    correct_answers = 0
+    for i in range(len(img_list)):
+        indexes = np.argsort(net_output_blob[i])[-5:]
+        correct_index = img_classes[img_list[i]]
+        if correct_index in indexes:
+            correct_answers += 1
+    return correct_answers
+
+
+class Framework(object):
+    in_blob_name = ''
+    out_blob_name = ''
+
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def get_name(self):
+        pass
+
+    @abstractmethod
+    def get_output(self, input_blob):
+        pass
+
+
+class CaffeModel(Framework):
+    net = caffe.Net
+    need_reshape = False
+
+    def __init__(self, prototxt, caffemodel, in_blob_name, out_blob_name, need_reshape=False):
+        caffe.set_mode_cpu()
+        self.net = caffe.Net(prototxt, caffemodel, caffe.TEST)
+        self.in_blob_name = in_blob_name
+        self.out_blob_name = out_blob_name
+        self.need_reshape = need_reshape
+
+    def get_name(self):
+        return 'Caffe'
+
+    def get_output(self, input_blob):
+        if self.need_reshape:
+            self.net.blobs[self.in_blob_name].reshape(*input_blob.shape)
+        return self.net.forward_all(**{self.in_blob_name: input_blob})[self.out_blob_name]
+
+
+class DnnCaffeModel(Framework):
+    net = object
+
+    def __init__(self, prototxt, caffemodel, in_blob_name, out_blob_name):
+        self.net = cv.dnn.readNetFromCaffe(prototxt, caffemodel)
+        self.in_blob_name = in_blob_name
+        self.out_blob_name = out_blob_name
+
+    def get_name(self):
+        return 'DNN'
+
+    def get_output(self, input_blob):
+        self.net.setBlob(self.in_blob_name, input_blob)
+        self.net.forward()
+        return self.net.getBlob(self.out_blob_name)
+
+
+class ClsAccEvaluation:
+    log = file
+    img_classes = {}
+    batch_size = 0
+
+    def __init__(self, log_path, img_classes_file, batch_size):
+        self.log = open(log_path, 'w')
+        self.img_classes = self.read_classes(img_classes_file)
+        self.batch_size = batch_size
+
+    @staticmethod
+    def read_classes(img_classes_file):
+        result = {}
+        with open(img_classes_file) as file:
+            for l in file.readlines():
+                result[l.split()[0]] = int(l.split()[1])
+        return result
+
+    def process(self, frameworks, data_fetcher):
+        sorted_imgs_names = sorted(self.img_classes.keys())
+        correct_answers = [0] * len(frameworks)
+        samples_handled = 0
+        blobs_l1_diff = [0] * len(frameworks)
+        blobs_l1_diff_count = [0] * len(frameworks)
+        blobs_l_inf_diff = [sys.float_info.min] * len(frameworks)
+        inference_time = [0.0] * len(frameworks)
+
+        for x in xrange(0, len(sorted_imgs_names), self.batch_size):
+            sublist = sorted_imgs_names[x:x + self.batch_size]
+            batch = data_fetcher.get_batch(sublist)
+
+            samples_handled += len(sublist)
+
+            frameworks_out = []
+            fw_accuracy = []
+            for i in range(len(frameworks)):
+                start = time.time()
+                out = frameworks[i].get_output(batch)
+                end = time.time()
+                correct_answers[i] += get_correct_answers(sublist, self.img_classes, out)
+                fw_accuracy.append(100 * correct_answers[i] / float(samples_handled))
+                frameworks_out.append(out)
+                inference_time[i] += end - start
+                print >> self.log, samples_handled, 'Accuracy for', frameworks[i].get_name() + ':', fw_accuracy[i]
+                print >> self.log, "Inference time, ms ", \
+                    frameworks[i].get_name(), inference_time[i] / samples_handled * 1000
+
+            for i in range(1, len(frameworks)):
+                log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':'
+                diff = np.abs(frameworks_out[0] - frameworks_out[i])
+                l1_diff = np.sum(diff) / diff.size
+                print >> self.log, samples_handled, "L1 difference", log_str, l1_diff
+                blobs_l1_diff[i] += l1_diff
+                blobs_l1_diff_count[i] += 1
+                if np.max(diff) > blobs_l_inf_diff[i]:
+                    blobs_l_inf_diff[i] = np.max(diff)
+                print >> self.log, samples_handled, "L_INF difference", log_str, blobs_l_inf_diff[i]
+
+            self.log.flush()
+
+        for i in range(1, len(blobs_l1_diff)):
+            log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':'
+            print >> self.log, 'Final l1 diff', log_str, blobs_l1_diff[i] / blobs_l1_diff_count[i]
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--imgs_dir", help="path to ImageNet validation subset images dir, ILSVRC2012_img_val dir")
+    parser.add_argument("--img_cls_file", help="path to file with classes ids for images, val.txt file from this "
+                                               "archive: http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz")
+    parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: "
+                                        "https://github.com/BVLC/caffe/blob/master/models/bvlc_alexnet/deploy.prototxt")
+    parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: "
+                                             "http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel")
+    parser.add_argument("--log", help="path to logging file")
+    parser.add_argument("--mean", help="path to ImageNet mean blob caffe file, imagenet_mean.binaryproto file from"
+                                       "this archive: http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz")
+    parser.add_argument("--batch_size", help="size of images in batch", default=1000)
+    parser.add_argument("--frame_size", help="size of input image", default=227)
+    parser.add_argument("--in_blob", help="name for input blob", default='data')
+    parser.add_argument("--out_blob", help="name for output blob", default='prob')
+    args = parser.parse_args()
+
+    data_fetcher = MeanBlobFetch(args.frame_size, args.mean, args.imgs_dir)
+
+    frameworks = [CaffeModel(args.prototxt, args.caffemodel, args.in_blob, args.out_blob),
+                  DnnCaffeModel(args.prototxt, args.caffemodel, '', args.out_blob)]
+
+    acc_eval = ClsAccEvaluation(args.log, args.img_cls_file, args.batch_size)
+    acc_eval.process(frameworks, data_fetcher)

modules/dnn/test/imagenet_cls_test_googlenet.py

@@ -0,0 +1,43 @@
+import numpy as np
+import sys
+import os
+import argparse
+from imagenet_cls_test_alexnet import MeanChannelsFetch, CaffeModel, DnnCaffeModel, ClsAccEvaluation
+# sys.path.append('<path to git/caffe/python dir>')
+sys.path.append('/home/arrybn/git/caffe/python')
+try:
+    import caffe
+except ImportError:
+    raise ImportError('Can\'t find caffe. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to git/caffe/python dir')
+# sys.path.append('<path to opencv_build_dir/lib>')
+sys.path.append('/home/arrybn/build/opencv_w_contrib/lib')
+try:
+    import cv2 as cv
+except ImportError:
+    raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to opencv_build_dir/lib dir')
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--imgs_dir", help="path to ImageNet validation subset images dir, ILSVRC2012_img_val dir")
+    parser.add_argument("--img_cls_file", help="path to file with classes ids for images, val.txt file from this "
+                                               "archive: http://dl.caffe.berkeleyvision.org/caffe_ilsvrc12.tar.gz")
+    parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: "
+                                        "https://github.com/BVLC/caffe/blob/master/models/bvlc_alexnet/deploy.prototxt")
+    parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: "
+                                             "http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel")
+    parser.add_argument("--log", help="path to logging file")
+    parser.add_argument("--batch_size", help="size of images in batch", default=500, type=int)
+    parser.add_argument("--frame_size", help="size of input image", default=224, type=int)
+    parser.add_argument("--in_blob", help="name for input blob", default='data')
+    parser.add_argument("--out_blob", help="name for output blob", default='prob')
+    args = parser.parse_args()
+
+    data_fetcher = MeanChannelsFetch(args.frame_size, args.imgs_dir)
+
+    frameworks = [CaffeModel(args.prototxt, args.caffemodel, args.in_blob, args.out_blob),
+                  DnnCaffeModel(args.prototxt, args.caffemodel, '', args.out_blob)]
+
+    acc_eval = ClsAccEvaluation(args.log, args.img_cls_file, args.batch_size)
+    acc_eval.process(frameworks, data_fetcher)

modules/dnn/test/imagenet_cls_test_inception.py

@@ -0,0 +1,79 @@
+import numpy as np
+import sys
+import os
+import argparse
+import tensorflow as tf
+from tensorflow.python.platform import gfile
+from imagenet_cls_test_alexnet import MeanValueFetch, DnnCaffeModel, Framework, ClsAccEvaluation
+# sys.path.append('<path to opencv_build_dir/lib>')
+sys.path.append('/home/arrybn/build/opencv_w_contrib/lib')
+try:
+    import cv2 as cv
+except ImportError:
+    raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to opencv_build_dir/lib dir')
+
+# If you've got an exception "Cannot load libmkl_avx.so or libmkl_def.so" or similar, try to export next variable
+# before runnigng the script:
+# LD_PRELOAD=/opt/intel/mkl/lib/intel64/libmkl_core.so:/opt/intel/mkl/lib/intel64/libmkl_sequential.so
+
+
+class TensorflowModel(Framework):
+    sess = tf.Session
+    output = tf.Graph
+
+    def __init__(self, model_file, in_blob_name, out_blob_name):
+        self.in_blob_name = in_blob_name
+        self.sess = tf.Session()
+        with gfile.FastGFile(model_file, 'rb') as f:
+            graph_def = tf.GraphDef()
+            graph_def.ParseFromString(f.read())
+            self.sess.graph.as_default()
+            tf.import_graph_def(graph_def, name='')
+        self.output = self.sess.graph.get_tensor_by_name(out_blob_name + ":0")
+
+    def get_name(self):
+        return 'Tensorflow'
+
+    def get_output(self, input_blob):
+        assert len(input_blob.shape) == 4
+        batch_tf = input_blob.transpose(0, 2, 3, 1)
+        out = self.sess.run(self.output,
+                       {self.in_blob_name+':0': batch_tf})
+        out = out[..., 1:1001]
+        return out
+
+
+class DnnTfInceptionModel(DnnCaffeModel):
+    net = cv.dnn.Net()
+
+    def __init__(self, model_file, in_blob_name, out_blob_name):
+        self.net = cv.dnn.readNetFromTensorflow(model_file)
+        self.in_blob_name = in_blob_name
+        self.out_blob_name = out_blob_name
+
+    def get_output(self, input_blob):
+        return super(DnnTfInceptionModel, self).get_output(input_blob)[..., 1:1001]
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--imgs_dir", help="path to ImageNet validation subset images dir, ILSVRC2012_img_val dir")
+    parser.add_argument("--img_cls_file", help="path to file with classes ids for images, download it here:"
+                            "https://github.com/opencv/opencv_extra/tree/master/testdata/dnn/img_classes_inception.txt")
+    parser.add_argument("--model", help="path to tensorflow model, download it here:"
+                                        "https://storage.googleapis.com/download.tensorflow.org/models/inception5h.zip")
+    parser.add_argument("--log", help="path to logging file")
+    parser.add_argument("--batch_size", help="size of images in batch", default=1)
+    parser.add_argument("--frame_size", help="size of input image", default=224)
+    parser.add_argument("--in_blob", help="name for input blob", default='input')
+    parser.add_argument("--out_blob", help="name for output blob", default='softmax2')
+    args = parser.parse_args()
+
+    data_fetcher = MeanValueFetch(args.frame_size, args.imgs_dir, True)
+
+    frameworks = [TensorflowModel(args.model, args.in_blob, args.out_blob),
+                  DnnTfInceptionModel(args.model, '', args.out_blob)]
+
+    acc_eval = ClsAccEvaluation(args.log, args.img_cls_file, args.batch_size)
+    acc_eval.process(frameworks, data_fetcher)

modules/dnn/test/npy_blob.hpp

@@ -0,0 +1,65 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_DNN_TEST_NPY_BLOB_HPP__
+#define __OPENCV_DNN_TEST_NPY_BLOB_HPP__
+#include "test_precomp.hpp"
+#include "cnpy.h"
+
+namespace cv
+{
+
+inline Mat blobFromNPY(const String &path)
+{
+    cnpy::NpyArray npyBlob = cnpy::npy_load(path.c_str());
+    Mat blob = Mat((int)npyBlob.shape.size(), (int*)&npyBlob.shape[0], CV_32F, npyBlob.data).clone();
+    npyBlob.destruct();
+    return blob;
+}
+
+inline void saveBlobToNPY(const Mat &blob, const String &path)
+{
+    cnpy::npy_save(path.c_str(), blob.ptr<float>(), (unsigned*)&blob.size.p[0], blob.dims);
+}
+
+}
+
+#endif

modules/dnn/test/pascal_semsegm_test_fcn.py

@@ -0,0 +1,225 @@
+from abc import ABCMeta, abstractmethod
+import numpy as np
+import sys
+import argparse
+import time
+
+from imagenet_cls_test_alexnet import CaffeModel, DnnCaffeModel
+sys.path.append('/home/arrybn/build/opencv_w_contrib/lib')
+try:
+    import cv2 as cv
+except ImportError:
+    raise ImportError('Can\'t find opencv. If you\'ve built it from sources without installation, '
+                      'uncomment the line before and insert there path to opencv_build_dir/lib dir')
+
+
+def get_metrics(conf_mat):
+    pix_accuracy = np.trace(conf_mat) / np.sum(conf_mat)
+    t = np.sum(conf_mat, 1)
+    num_cl = np.count_nonzero(t)
+    assert num_cl
+    mean_accuracy = np.sum(np.nan_to_num(np.divide(np.diagonal(conf_mat), t))) / num_cl
+    col_sum = np.sum(conf_mat, 0)
+    mean_iou = np.sum(
+        np.nan_to_num(np.divide(np.diagonal(conf_mat), (t + col_sum - np.diagonal(conf_mat))))) / num_cl
+    return pix_accuracy, mean_accuracy, mean_iou
+
+
+def eval_segm_result(net_out):
+    assert type(net_out) is np.ndarray
+    assert len(net_out.shape) == 4
+
+    channels_dim = 1
+    y_dim = channels_dim + 1
+    x_dim = y_dim + 1
+    res = np.zeros(net_out.shape).astype(np.int)
+    for i in range(net_out.shape[y_dim]):
+        for j in range(net_out.shape[x_dim]):
+            max_ch = np.argmax(net_out[..., i, j])
+            res[0, max_ch, i, j] = 1
+    return res
+
+
+def get_conf_mat(gt, prob):
+    assert type(gt) is np.ndarray
+    assert type(prob) is np.ndarray
+
+    conf_mat = np.zeros((gt.shape[0], gt.shape[0]))
+    for ch_gt in range(conf_mat.shape[0]):
+        gt_channel = gt[ch_gt, ...]
+        for ch_pr in range(conf_mat.shape[1]):
+            prob_channel = prob[ch_pr, ...]
+            conf_mat[ch_gt][ch_pr] = np.count_nonzero(np.multiply(gt_channel, prob_channel))
+    return conf_mat
+
+
+class MeanChannelsPreproc:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def process(img):
+        image_data = np.array(img).transpose(2, 0, 1).astype(np.float32)
+        mean = np.ones(image_data.shape)
+        mean[0] *= 104
+        mean[1] *= 117
+        mean[2] *= 123
+        image_data -= mean
+        image_data = np.expand_dims(image_data, 0)
+        return image_data
+
+
+class DatasetImageFetch(object):
+    __metaclass__ = ABCMeta
+    data_prepoc = object
+
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+    @abstractmethod
+    def next(self):
+        pass
+
+    @staticmethod
+    def pix_to_c(pix):
+        return pix[0] * 256 * 256 + pix[1] * 256 + pix[2]
+
+    @staticmethod
+    def color_to_gt(color_img, colors):
+        num_classes = len(colors)
+        gt = np.zeros((num_classes, color_img.shape[0], color_img.shape[1])).astype(np.int)
+        for img_y in range(color_img.shape[0]):
+            for img_x in range(color_img.shape[1]):
+                c = DatasetImageFetch.pix_to_c(color_img[img_y][img_x])
+                if c in colors:
+                    cls = colors.index(c)
+                    gt[cls][img_y][img_x] = 1
+        return gt
+
+
+class PASCALDataFetch(DatasetImageFetch):
+    img_dir = ''
+    segm_dir = ''
+    names = []
+    colors = []
+    i = 0
+
+    def __init__(self, img_dir, segm_dir, names_file, segm_cls_colors_file, preproc):
+        self.img_dir = img_dir
+        self.segm_dir = segm_dir
+        self.colors = self.read_colors(segm_cls_colors_file)
+        self.data_prepoc = preproc
+        self.i = 0
+
+        with open(names_file) as f:
+            for l in f.readlines():
+                self.names.append(l.rstrip())
+
+    @staticmethod
+    def read_colors(img_classes_file):
+        result = []
+        with open(img_classes_file) as f:
+            for l in f.readlines():
+                color = np.array(map(int, l.split()[1:]))
+                result.append(DatasetImageFetch.pix_to_c(color))
+        return result
+
+    def __iter__(self):
+        return self
+
+    def next(self):
+        if self.i < len(self.names):
+            name = self.names[self.i]
+            self.i += 1
+            segm_file = self.segm_dir + name + ".png"
+            img_file = self.img_dir + name + ".jpg"
+            gt = self.color_to_gt(cv.imread(segm_file, cv.IMREAD_COLOR)[:, :, ::-1], self.colors)
+            img = self.data_prepoc.process(cv.imread(img_file, cv.IMREAD_COLOR)[:, :, ::-1])
+            return img, gt
+        else:
+            self.i = 0
+            raise StopIteration
+
+    def get_num_classes(self):
+        return len(self.colors)
+
+
+class SemSegmEvaluation:
+    log = file
+
+    def __init__(self, log_path,):
+        self.log = open(log_path, 'w')
+
+    def process(self, frameworks, data_fetcher):
+        samples_handled = 0
+
+        conf_mats = [np.zeros((data_fetcher.get_num_classes(), data_fetcher.get_num_classes())) for i in range(len(frameworks))]
+        blobs_l1_diff = [0] * len(frameworks)
+        blobs_l1_diff_count = [0] * len(frameworks)
+        blobs_l_inf_diff = [sys.float_info.min] * len(frameworks)
+        inference_time = [0.0] * len(frameworks)
+
+        for in_blob, gt in data_fetcher:
+            frameworks_out = []
+            samples_handled += 1
+            for i in range(len(frameworks)):
+                start = time.time()
+                out = frameworks[i].get_output(in_blob)
+                end = time.time()
+                segm = eval_segm_result(out)
+                conf_mats[i] += get_conf_mat(gt, segm[0])
+                frameworks_out.append(out)
+                inference_time[i] += end - start
+
+                pix_acc, mean_acc, miou = get_metrics(conf_mats[i])
+
+                name = frameworks[i].get_name()
+                print >> self.log, samples_handled, 'Pixel accuracy, %s:' % name, 100 * pix_acc
+                print >> self.log, samples_handled, 'Mean accuracy, %s:' % name, 100 * mean_acc
+                print >> self.log, samples_handled, 'Mean IOU, %s:' % name, 100 * miou
+                print >> self.log, "Inference time, ms ", \
+                    frameworks[i].get_name(), inference_time[i] / samples_handled * 1000
+
+            for i in range(1, len(frameworks)):
+                log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':'
+                diff = np.abs(frameworks_out[0] - frameworks_out[i])
+                l1_diff = np.sum(diff) / diff.size
+                print >> self.log, samples_handled, "L1 difference", log_str, l1_diff
+                blobs_l1_diff[i] += l1_diff
+                blobs_l1_diff_count[i] += 1
+                if np.max(diff) > blobs_l_inf_diff[i]:
+                    blobs_l_inf_diff[i] = np.max(diff)
+                print >> self.log, samples_handled, "L_INF difference", log_str, blobs_l_inf_diff[i]
+
+            self.log.flush()
+
+        for i in range(1, len(blobs_l1_diff)):
+            log_str = frameworks[0].get_name() + " vs " + frameworks[i].get_name() + ':'
+            print >> self.log, 'Final l1 diff', log_str, blobs_l1_diff[i] / blobs_l1_diff_count[i]
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--imgs_dir", help="path to PASCAL VOC 2012 images dir, data/VOC2012/JPEGImages")
+    parser.add_argument("--segm_dir", help="path to PASCAL VOC 2012 segmentation dir, data/VOC2012/SegmentationClass/")
+    parser.add_argument("--val_names", help="path to file with validation set image names, download it here: "
+                        "https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/data/pascal/seg11valid.txt")
+    parser.add_argument("--cls_file", help="path to file with colors for classes, download it here: "
+                        "https://github.com/opencv/opencv_contrib/blob/master/modules/dnn/samples/pascal-classes.txt")
+    parser.add_argument("--prototxt", help="path to caffe prototxt, download it here: "
+                        "https://github.com/opencv/opencv_contrib/blob/master/modules/dnn/samples/fcn8s-heavy-pascal.prototxt")
+    parser.add_argument("--caffemodel", help="path to caffemodel file, download it here: "
+                                             "http://dl.caffe.berkeleyvision.org/fcn8s-heavy-pascal.caffemodel")
+    parser.add_argument("--log", help="path to logging file")
+    parser.add_argument("--in_blob", help="name for input blob", default='data')
+    parser.add_argument("--out_blob", help="name for output blob", default='score')
+    args = parser.parse_args()
+
+    prep = MeanChannelsPreproc()
+    df = PASCALDataFetch(args.imgs_dir, args.segm_dir, args.val_names, args.cls_file, prep)
+
+    fw = [CaffeModel(args.prototxt, args.caffemodel, args.in_blob, args.out_blob, True),
+          DnnCaffeModel(args.prototxt, args.caffemodel, '', args.out_blob)]
+
+    segm_eval = SemSegmEvaluation(args.log)
+    segm_eval.process(fw, df)

modules/dnn/test/test_caffe_importer.cpp

@@ -0,0 +1,160 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include "npy_blob.hpp"
+#include <opencv2/dnn/shape_utils.hpp>
+
+namespace cvtest
+{
+
+using namespace cv;
+using namespace cv::dnn;
+
+template<typename TString>
+static std::string _tf(TString filename)
+{
+    return (getOpenCVExtraDir() + "/dnn/") + filename;
+}
+
+TEST(Test_Caffe, read_gtsrb)
+{
+    Net net;
+    {
+        Ptr<Importer> importer = createCaffeImporter(_tf("gtsrb.prototxt"), "");
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+}
+
+TEST(Test_Caffe, read_googlenet)
+{
+    Net net;
+    {
+        Ptr<Importer> importer = createCaffeImporter(_tf("bvlc_googlenet.prototxt"), "");
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+}
+
+TEST(Reproducibility_AlexNet, Accuracy)
+{
+    Net net;
+    {
+        const string proto = findDataFile("dnn/bvlc_alexnet.prototxt", false);
+        const string model = findDataFile("dnn/bvlc_alexnet.caffemodel", false);
+        Ptr<Importer> importer = createCaffeImporter(proto, model);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat sample = imread(_tf("grace_hopper_227.png"));
+    ASSERT_TRUE(!sample.empty());
+
+    Size inputSize(227, 227);
+
+    if (sample.size() != inputSize)
+        resize(sample, sample, inputSize);
+
+    net.setInput(blobFromImage(sample), "data");
+    Mat out = net.forward("prob");
+    Mat ref = blobFromNPY(_tf("caffe_alexnet_prob.npy"));
+    normAssert(ref, out);
+}
+
+#if !defined(_WIN32) || defined(_WIN64)
+TEST(Reproducibility_FCN, Accuracy)
+{
+    Net net;
+    {
+        const string proto = findDataFile("dnn/fcn8s-heavy-pascal.prototxt", false);
+        const string model = findDataFile("dnn/fcn8s-heavy-pascal.caffemodel", false);
+        Ptr<Importer> importer = createCaffeImporter(proto, model);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat sample = imread(_tf("street.png"));
+    ASSERT_TRUE(!sample.empty());
+
+    Size inputSize(500, 500);
+    if (sample.size() != inputSize)
+        resize(sample, sample, inputSize);
+
+    std::vector<int> layerIds;
+    std::vector<size_t> weights, blobs;
+    net.getMemoryConsumption(shape(1,3,227,227), layerIds, weights, blobs);
+
+    net.setInput(blobFromImage(sample), "data");
+    Mat out = net.forward("score");
+    Mat ref = blobFromNPY(_tf("caffe_fcn8s_prob.npy"));
+    normAssert(ref, out);
+}
+#endif
+
+TEST(Reproducibility_SSD, Accuracy)
+{
+    Net net;
+    {
+        const string proto = findDataFile("dnn/ssd_vgg16.prototxt", false);
+        const string model = findDataFile("dnn/VGG_ILSVRC2016_SSD_300x300_iter_440000.caffemodel", false);
+        Ptr<Importer> importer = createCaffeImporter(proto, model);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat sample = imread(_tf("street.png"));
+    ASSERT_TRUE(!sample.empty());
+
+    if (sample.channels() == 4)
+        cvtColor(sample, sample, COLOR_BGRA2BGR);
+
+    sample.convertTo(sample, CV_32F);
+    resize(sample, sample, Size(300, 300));
+
+    Mat in_blob = blobFromImage(sample);
+    net.setInput(in_blob, "data");
+    Mat out = net.forward("detection_out");
+
+    Mat ref = blobFromNPY(_tf("ssd_out.npy"));
+    normAssert(ref, out);
+}
+}

modules/dnn/test/test_common.hpp

@@ -0,0 +1,60 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_TEST_COMMON_HPP__
+#define __OPENCV_TEST_COMMON_HPP__
+
+inline const std::string &getOpenCVExtraDir()
+{
+    return cvtest::TS::ptr()->get_data_path();
+}
+
+inline void normAssert(cv::InputArray ref, cv::InputArray test, const char *comment = "",
+                       double l1 = 0.00001, double lInf = 0.0001)
+{
+    double normL1 = cvtest::norm(ref, test, cv::NORM_L1) / ref.getMat().total();
+    EXPECT_LE(normL1, l1) << comment;
+
+    double normInf = cvtest::norm(ref, test, cv::NORM_INF);
+    EXPECT_LE(normInf, lInf) << comment;
+}
+
+#endif

modules/dnn/test/test_googlenet.cpp

@@ -0,0 +1,107 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include "npy_blob.hpp"
+#include <opencv2/core/ocl.hpp>
+#include <opencv2/ts/ocl_test.hpp>
+
+namespace cvtest
+{
+
+using namespace cv;
+using namespace cv::dnn;
+
+template<typename TString>
+static std::string _tf(TString filename)
+{
+    return (getOpenCVExtraDir() + "/dnn/") + filename;
+}
+
+static void launchGoogleNetTest()
+{
+    Net net;
+    {
+        const string proto = findDataFile("dnn/bvlc_googlenet.prototxt", false);
+        const string model = findDataFile("dnn/bvlc_googlenet.caffemodel", false);
+        Ptr<Importer> importer = createCaffeImporter(proto, model);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    std::vector<Mat> inpMats;
+    inpMats.push_back( imread(_tf("googlenet_0.png")) );
+    inpMats.push_back( imread(_tf("googlenet_1.png")) );
+    ASSERT_TRUE(!inpMats[0].empty() && !inpMats[1].empty());
+
+    net.setInput(blobFromImages(inpMats), "data");
+    Mat out = net.forward("prob");
+
+    Mat ref = blobFromNPY(_tf("googlenet_prob.npy"));
+    normAssert(out, ref);
+
+    std::vector<String> blobsNames;
+    blobsNames.push_back("conv1/7x7_s2");
+    blobsNames.push_back("conv1/relu_7x7");
+    blobsNames.push_back("inception_4c/1x1");
+    blobsNames.push_back("inception_4c/relu_1x1");
+    std::vector<Mat> outs;
+    Mat in = blobFromImage(inpMats[0]);
+    net.setInput(in, "data");
+    net.forward(outs, blobsNames);
+    CV_Assert(outs.size() == blobsNames.size());
+
+    for (int i = 0; i < blobsNames.size(); i++)
+    {
+        std::string filename = blobsNames[i];
+        std::replace( filename.begin(), filename.end(), '/', '#');
+        Mat ref = blobFromNPY(_tf("googlenet_" + filename + ".npy"));
+
+        normAssert(outs[i], ref, "", 1E-4, 1E-2);
+    }
+}
+
+TEST(Reproducibility_GoogLeNet, Accuracy)
+{
+    launchGoogleNetTest();
+}
+
+}

modules/dnn/test/test_halide_layers.cpp

@@ -0,0 +1,626 @@
+// 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.
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+// This tests doesn't require any external data. They just compare outputs of
+// layers using different computation backends. Input and parameters are random.
+
+namespace cvtest
+{
+
+#ifdef HAVE_HALIDE
+using namespace cv;
+using namespace cv::dnn;
+using namespace testing;
+
+static void test(LayerParams& params, Mat& input)
+{
+    randu(input, -1.0f, 1.0f);
+
+    Net net;
+    int lid = net.addLayer(params.name, params.type, params);
+    net.connect(0, 0, lid, 0);
+
+    net.setInput(input);
+    Mat outputDefault = net.forward(params.name).clone();
+
+    net.setPreferableBackend(DNN_BACKEND_HALIDE);
+    Mat outputHalide = net.forward(params.name).clone();
+    normAssert(outputDefault, outputHalide);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Convolution
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<Vec3i, Size, Size, Size, Size, Size, bool> > Convolution;
+TEST_P(Convolution, Accuracy)
+{
+    int inChannels = get<0>(GetParam())[0];
+    int outChannels = get<0>(GetParam())[1];
+    int group = get<0>(GetParam())[2];
+    Size inSize = get<1>(GetParam());
+    Size kernel = get<2>(GetParam());
+    Size stride = get<3>(GetParam());
+    Size pad = get<4>(GetParam());
+    Size dilation = get<5>(GetParam());
+    bool hasBias = get<6>(GetParam());
+
+    Mat weights({outChannels, inChannels / group, kernel.height, kernel.width}, CV_32F);
+    randu(weights, -1.0f, 1.0f);
+
+    LayerParams lp;
+    lp.set("kernel_w", kernel.width);
+    lp.set("kernel_h", kernel.height);
+    lp.set("pad_w", pad.width);
+    lp.set("pad_h", pad.height);
+    lp.set("stride_w", stride.width);
+    lp.set("stride_h", stride.height);
+    lp.set("dilation_w", dilation.width);
+    lp.set("dilation_h", dilation.height);
+    lp.set("num_output", outChannels);
+    lp.set("group", group);
+    lp.set("bias_term", hasBias);
+    lp.type = "Convolution";
+    lp.name = "testLayer";
+    lp.blobs.push_back(weights);
+    if (hasBias)
+    {
+        Mat bias({outChannels}, CV_32F);
+        randu(bias, -1.0f, 1.0f);
+        lp.blobs.push_back(bias);
+    }
+    Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Convolution, Combine(
+/*in channels, out channels, group*/
+             Values(Vec3i(6, 4, 1), Vec3i(6, 9, 1),
+                    Vec3i(6, 4, 2), Vec3i(6, 9, 3)),
+/*in size*/  Values(Size(5, 6)),
+/*kernel*/   Values(Size(3, 1), Size(1, 3)),
+/*stride*/   Values(Size(1, 1), Size(2, 2)),
+/*pad*/      Values(Size(1, 0), Size(0, 1)),
+/*dilation*/ Values(Size(1, 1), Size(2, 2)),
+/*has bias*/ Bool()
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// Deconvolution
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<Vec3i, Size, Size, Size, Size, Vec4i, bool> > Deconvolution;
+TEST_P(Deconvolution, Accuracy)
+{
+    int inChannels = get<0>(GetParam())[0];
+    int outChannels = get<0>(GetParam())[1];
+    int group = get<0>(GetParam())[2];
+    Size inSize = get<1>(GetParam());
+    Size kernel = get<2>(GetParam());
+    Size pad = get<3>(GetParam());
+    Size dilation = get<4>(GetParam());
+    Size stride = Size(get<5>(GetParam())[0], get<5>(GetParam())[1]);
+    Size adjPad = Size(get<5>(GetParam())[2], get<5>(GetParam())[3]);
+    bool hasBias = get<6>(GetParam());
+
+    Mat weights({outChannels, inChannels / group, kernel.height, kernel.width}, CV_32F);
+    randu(weights, -1.0f, 1.0f);
+
+    LayerParams lp;
+    lp.set("kernel_w", kernel.width);
+    lp.set("kernel_h", kernel.height);
+    lp.set("pad_w", pad.width);
+    lp.set("pad_h", pad.height);
+    lp.set("stride_w", stride.width);
+    lp.set("stride_h", stride.height);
+    lp.set("dilation_w", dilation.width);
+    lp.set("dilation_h", dilation.height);
+    lp.set("adj_w", adjPad.width);
+    lp.set("adj_h", adjPad.height);
+    lp.set("num_output", outChannels);
+    lp.set("group", group);
+    lp.set("bias_term", hasBias);
+    lp.type = "Deconvolution";
+    lp.name = "testLayer";
+    lp.blobs.push_back(weights);
+    if (hasBias)
+    {
+        Mat bias({outChannels}, CV_32F);
+        randu(bias, -1.0f, 1.0f);
+        lp.blobs.push_back(bias);
+    }
+    Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Deconvolution, Combine(
+/*in channels, out channels, group*/
+             Values(Vec3i(6, 4, 1), Vec3i(6, 9, 1)),
+/*in size*/  Values(Size(5, 6)),
+/*kernel*/   Values(Size(3, 1), Size(1, 3)),
+/*pad*/      Values(Size(1, 0), Size(0, 1)),
+/*dilation*/ Values(Size(1, 1), Size(2, 2)),
+/*stride, adj. pad*/ Values(Vec4i(1,1, 0,0), Vec4i(2,2, 1,0), Vec4i(1,2, 0,1)),
+/*has bias*/ Bool()
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// LRN
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<Vec3i, int, Vec3f, bool, std::string> > LRN;
+TEST_P(LRN, Accuracy)
+{
+    int inChannels = get<0>(GetParam())[0];
+    Size inSize = Size(get<0>(GetParam())[1], get<0>(GetParam())[2]);
+    int localSize = get<1>(GetParam());
+    float alpha = get<2>(GetParam())[0];
+    float beta = get<2>(GetParam())[1];
+    float bias = get<2>(GetParam())[2];
+    bool normBySize = get<3>(GetParam());
+    std::string nrmType = get<4>(GetParam());
+
+    LayerParams lp;
+    lp.set("norm_region", nrmType);
+    lp.set("local_size", localSize);
+    lp.set("alpha", alpha);
+    lp.set("beta", beta);
+    lp.set("bias", bias);
+    lp.set("norm_by_size", normBySize);
+    lp.type = "LRN";
+    lp.name = "testLayer";
+
+    Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, LRN, Combine(
+/*input ch,w,h*/ Values(Vec3i(6, 5, 8), Vec3i(7, 11, 6)),
+/*local size*/   Values(3, 5),
+                 Values(Vec3f(0.9f, 1.0f, 1.1f), Vec3f(0.9f, 1.1f, 1.0f),
+/*alpha, beta,*/        Vec3f(1.0f, 0.9f, 1.1f), Vec3f(1.0f, 1.1f, 0.9f),
+/*bias */               Vec3f(1.1f, 0.9f, 1.0f), Vec3f(1.1f, 1.0f, 0.9f)),
+/*norm_by_size*/ Bool(),
+/*norm_type*/    Values("ACROSS_CHANNELS", "WITHIN_CHANNEL")
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// Average pooling
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<int, Size, Size, Size> > AvePooling;
+TEST_P(AvePooling, Accuracy)
+{
+    int inChannels = get<0>(GetParam());
+    Size outSize = get<1>(GetParam());;  // Input size will be computed from parameters.
+    Size kernel = get<2>(GetParam());
+    Size stride = get<3>(GetParam());
+
+    const int inWidth = (outSize.width - 1) * stride.width + kernel.width;
+    const int inHeight = (outSize.height - 1) * stride.height + kernel.height;
+
+    LayerParams lp;
+    lp.set("pool", "ave");
+    lp.set("kernel_w", kernel.width);
+    lp.set("kernel_h", kernel.height);
+    lp.set("stride_w", stride.width);
+    lp.set("stride_h", stride.height);
+    lp.type = "Pooling";
+    lp.name = "testLayer";
+
+    Mat input({1, inChannels, inHeight, inWidth}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, AvePooling, Combine(
+/*in channels*/ Values(3, 4),
+/*out size*/    Values(Size(1, 1), Size(2, 2), Size(3, 2), Size(4, 7)),
+/*kernel*/      Values(Size(1, 1), Size(2, 2), Size(3, 3), Size(3, 2)),
+/*stride*/      Values(Size(1, 1), Size(2, 2), Size(3, 2))
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// Maximum pooling
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<int, Size, Size, Size, Size> > MaxPooling;
+TEST_P(MaxPooling, Accuracy)
+{
+    int inChannels = get<0>(GetParam());
+    Size inSize = get<1>(GetParam());
+    Size kernel = get<2>(GetParam());
+    Size stride = get<3>(GetParam());
+    Size pad = get<4>(GetParam());
+
+    LayerParams lp;
+    lp.set("pool", "max");
+    lp.set("kernel_w", kernel.width);
+    lp.set("kernel_h", kernel.height);
+    lp.set("stride_w", stride.width);
+    lp.set("stride_h", stride.height);
+    lp.set("pad_w", pad.width);
+    lp.set("pad_h", pad.height);
+    lp.type = "Pooling";
+    lp.name = "testLayer";
+
+    Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, MaxPooling, Combine(
+/*in channels*/ Values(3, 4),
+/*in size*/     Values(Size(5, 5), Size(7, 6)),
+/*kernel*/      Values(Size(2, 2), Size(3, 3), Size(3, 2)),
+/*stride*/      Values(Size(1, 1), Size(2, 2), Size(3, 2)),
+/*pad*/         Values(Size(0, 0), Size(1, 1), Size(0, 1))
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// Fully-connected
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<int, Size, int, bool> > FullyConnected;
+TEST_P(FullyConnected, Accuracy)
+{
+    int inChannels = get<0>(GetParam());
+    Size inSize = get<1>(GetParam());
+    int outChannels = get<2>(GetParam());
+    bool hasBias = get<3>(GetParam());
+
+    Mat weights(outChannels, inChannels * inSize.height * inSize.width, CV_32F);
+    randu(weights, -1.0f, 1.0f);
+
+    Mat bias(1, outChannels, CV_32F);
+    randu(bias, -1.0f, 1.0f);
+
+    LayerParams lp;
+    lp.set("num_output", outChannels);
+    lp.set("bias_term", hasBias);
+    lp.blobs.push_back(weights);
+    lp.blobs.push_back(bias);
+    lp.type = "InnerProduct";
+    lp.name = "testLayer";
+
+    Mat input({1, inChannels, inSize.height, inSize.width}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, FullyConnected, Combine(
+/*in channels*/  Values(3, 4),
+/*in size*/      Values(Size(5, 4), Size(4, 5), Size(1, 1)),
+/*out channels*/ Values(3, 4),
+/*has bias*/     Bool()
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// SoftMax
+////////////////////////////////////////////////////////////////////////////////
+typedef TestWithParam<tuple<int> > SoftMax;
+TEST_P(SoftMax, Accuracy)
+{
+    int inChannels = get<0>(GetParam());
+    LayerParams lp;
+    lp.type = "SoftMax";
+    lp.name = "testLayer";
+
+    Mat input({1, inChannels, 1, 1}, CV_32F);
+    test(lp, input);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, SoftMax, Values(3, 4, 5, 1024));
+
+//////////////////////////////////////////////////////////////////////////////
+// Max pooling - unpooling
+//////////////////////////////////////////////////////////////////////////////
+TEST(MaxPoolUnpool_Halide, Accuracy)
+{
+    LayerParams pool;
+    pool.set("pool", "max");
+    pool.set("kernel_w", 2);
+    pool.set("kernel_h", 2);
+    pool.set("stride_w", 2);
+    pool.set("stride_h", 2);
+    pool.set("pad_w", 0);
+    pool.set("pad_h", 0);
+    pool.type = "Pooling";
+    pool.name = "testPool";
+
+    LayerParams unpool;
+    unpool.set("pool_k_w", 2);
+    unpool.set("pool_k_h", 2);
+    unpool.set("pool_stride_w", 2);
+    unpool.set("pool_stride_h", 2);
+    unpool.set("pool_pad_w", 0);
+    unpool.set("pool_pad_h", 0);
+    unpool.type = "MaxUnpool";
+    unpool.name = "testUnpool";
+
+    Net net;
+    int poolId = net.addLayer(pool.name, pool.type, pool);
+    net.connect(0, 0, poolId, 0);
+
+    int unpoolId = net.addLayer(unpool.name, unpool.type, unpool);
+    net.connect(poolId, 0, unpoolId, 0);
+    net.connect(poolId, 1, unpoolId, 1);
+
+    Mat input({1, 1, 4, 4}, CV_32F);
+    randu(input, -1.0f, 1.0f);
+    net.setInput(input);
+    Mat outputDefault = net.forward("testUnpool").clone();
+
+    net.setPreferableBackend(DNN_BACKEND_HALIDE);
+    net.setInput(input);
+    Mat outputHalide = net.forward("testUnpool").clone();
+    normAssert(outputDefault, outputHalide);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AvePooling + in-place layers
+////////////////////////////////////////////////////////////////////////////////
+static const int kNumChannels = 3;
+
+void testInPlaceActivation(LayerParams& lp)
+{
+    EXPECT_FALSE(lp.name.empty());
+
+    LayerParams pool;
+    pool.set("pool", "ave");
+    pool.set("kernel_w", 2);
+    pool.set("kernel_h", 2);
+    pool.set("stride_w", 2);
+    pool.set("stride_h", 2);
+    pool.type = "Pooling";
+
+    Net net;
+    int poolId = net.addLayer(pool.name, pool.type, pool);
+    net.connect(0, 0, poolId, 0);
+    net.addLayerToPrev(lp.name, lp.type, lp);
+
+    Mat input({1, kNumChannels, 10, 10}, CV_32F);
+    randu(input, -1.0f, 1.0f);
+    net.setInput(input);
+    Mat outputDefault = net.forward(lp.name).clone();
+
+    net.setInput(input);
+    net.setPreferableBackend(DNN_BACKEND_HALIDE);
+    Mat outputHalide = net.forward(lp.name).clone();
+    normAssert(outputDefault, outputHalide);
+}
+
+typedef TestWithParam<tuple<bool, bool, float> > BatchNorm;
+TEST_P(BatchNorm, Accuracy)
+{
+    bool hasWeights = get<0>(GetParam());
+    bool hasBias = get<1>(GetParam());
+    float epsilon = get<2>(GetParam());
+
+    LayerParams lp;
+    lp.set("has_weight", hasWeights);
+    lp.set("has_bias", hasBias);
+    lp.set("eps", epsilon);
+    lp.type = "BatchNorm";
+    lp.name = "testLayer";
+
+    lp.blobs.reserve(4);
+    for (int i = 0; i < 3; ++i)
+        lp.blobs.push_back(Mat({kNumChannels}, CV_32F));
+    if (hasBias || hasWeights)
+        lp.blobs.push_back(Mat({kNumChannels}, CV_32F));
+
+    for (Mat& m : lp.blobs)
+        randu(m, 0.0f, 1.0f);
+
+    testInPlaceActivation(lp);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, BatchNorm, Combine(
+/*has weights*/ Bool(),
+/*has bias*/    Bool(),
+/*epsilon*/     Values(1e-3f, 1e-5f)
+));
+
+typedef TestWithParam<tuple<float> > ReLU;
+TEST_P(ReLU, Accuracy)
+{
+    float negativeSlope = get<0>(GetParam());
+
+    LayerParams lp;
+    lp.set("negative_slope", negativeSlope);
+    lp.type = "ReLU";
+    lp.name = "testLayer";
+    testInPlaceActivation(lp);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, ReLU, Values(
+/*negative slope*/ 2.0f, 0.3f, -0.1f
+));
+
+typedef TestWithParam<tuple<std::string> > NoParamActivation;
+TEST_P(NoParamActivation, Accuracy)
+{
+    LayerParams lp;
+    lp.type = get<0>(GetParam());
+    lp.name = "testLayer";
+    testInPlaceActivation(lp);
+}
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, NoParamActivation, Values(
+/*type*/ "TanH", "Sigmoid", "AbsVal", "BNLL"
+));
+
+typedef TestWithParam<tuple<Vec3f> > Power;
+TEST_P(Power, Accuracy)
+{
+    float power = get<0>(GetParam())[0];
+    float scale = get<0>(GetParam())[1];
+    float shift = get<0>(GetParam())[2];
+
+    LayerParams lp;
+    lp.set("power", power);
+    lp.set("scale", scale);
+    lp.set("shift", shift);
+    lp.type = "Power";
+    lp.name = "testLayer";
+    testInPlaceActivation(lp);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Power,
+/*power, scale, shift*/ Values(Vec3f(0.9f, 1.0f, 1.1f), Vec3f(0.9f, 1.1f, 1.0f),
+                               Vec3f(1.0f, 0.9f, 1.1f), Vec3f(1.0f, 1.1f, 0.9f),
+                               Vec3f(1.1f, 0.9f, 1.0f), Vec3f(1.1f, 1.0f, 0.9f))
+);
+
+TEST(ChannelsPReLU, Accuracy)
+{
+    LayerParams lp;
+    lp.type = "ChannelsPReLU";
+    lp.name = "testLayer";
+    lp.blobs.push_back(Mat({kNumChannels}, CV_32F));
+    randu(lp.blobs[0], -1.0f, 1.0f);
+
+    testInPlaceActivation(lp);
+}
+
+typedef TestWithParam<tuple<bool> > Scale;
+TEST_P(Scale, Accuracy)
+{
+    bool hasBias = get<0>(GetParam());
+
+    LayerParams lp;
+    lp.set("bias_term", hasBias);
+    lp.type = "Scale";
+    lp.name = "testLayer";
+    lp.blobs.push_back(Mat({kNumChannels}, CV_32F));
+    randu(lp.blobs[0], -1.0f, 1.0f);
+    if (hasBias)
+    {
+        lp.blobs.push_back(Mat({kNumChannels}, CV_32F));
+        randu(lp.blobs[1], -1.0f, 1.0f);
+    }
+    testInPlaceActivation(lp);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Scale, Values(true, false));
+
+////////////////////////////////////////////////////////////////////////////////
+// Concat layer
+////////////////////////////////////////////////////////////////////////////////
+//
+// input --- conv --- concat --- output
+//      `--- conv ----^ ^ ^
+//      `---- ... ------' '
+//      `-----------------'
+typedef TestWithParam<tuple<Vec3i, Vec3i> > Concat;
+TEST_P(Concat, Accuracy)
+{
+    Vec3i inSize = get<0>(GetParam());
+    Vec3i numChannels = get<1>(GetParam());
+
+    Net net;
+
+    LayerParams concatParam;
+    concatParam.type = "Concat";
+    concatParam.name = "testLayer";
+    int concatId = net.addLayer(concatParam.name, concatParam.type, concatParam);
+    net.connect(0, 0, concatId, 0);
+
+    for (int i = 0, n = numChannels.channels; i < n; ++i)
+    {
+        if (!numChannels[i])
+            break;
+
+        Mat weights({numChannels[i], inSize[0], 1, 1}, CV_32F);
+        randu(weights, -1.0f, 1.0f);
+
+        LayerParams convParam;
+        convParam.set("kernel_w", 1);
+        convParam.set("kernel_h", 1);
+        convParam.set("num_output", numChannels[i]);
+        convParam.set("bias_term", false);
+        convParam.type = "Convolution";
+        std::ostringstream ss;
+        ss << "convLayer" << i;
+        convParam.name = ss.str();
+        convParam.blobs.push_back(weights);
+
+        int convId = net.addLayer(convParam.name, convParam.type, convParam);
+        net.connect(0, 0, convId, 0);
+        net.connect(convId, 0, concatId, i + 1);
+    }
+
+    Mat input({1, inSize[0], inSize[1], inSize[2]}, CV_32F);
+    randu(input, -1.0f, 1.0f);
+
+    net.setInput(input);
+    Mat outputDefault = net.forward(concatParam.name).clone();
+
+    net.setPreferableBackend(DNN_BACKEND_HALIDE);
+    Mat outputHalide = net.forward(concatParam.name).clone();
+    normAssert(outputDefault, outputHalide);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Concat, Combine(
+/*input size*/ Values(Vec3i(1, 4, 5), Vec3i(2, 8, 6)),
+/*channels*/   Values(Vec3i(2, 0, 0), Vec3i(3, 4, 0), Vec3i(1, 6, 2))
+));
+
+////////////////////////////////////////////////////////////////////////////////
+// Element-wise layers
+////////////////////////////////////////////////////////////////////////////////
+//
+// input --- conv --- eltwise --- output
+//      `--- conv ----^ ^ ^
+//      `---- ... ------' '
+//      `-----------------'
+typedef TestWithParam<tuple<Vec3i, std::string, int> > Eltwise;
+TEST_P(Eltwise, Accuracy)
+{
+    Vec3i inSize = get<0>(GetParam());
+    std::string op = get<1>(GetParam());
+    int numConv = get<2>(GetParam());
+
+    Net net;
+
+    LayerParams eltwiseParam;
+    eltwiseParam.type = "Eltwise";
+    eltwiseParam.name = "testLayer";
+    int eltwiseId = net.addLayer(eltwiseParam.name, eltwiseParam.type, eltwiseParam);
+    net.connect(0, 0, eltwiseId, 0);
+
+    for (int i = 0; i < numConv; ++i)
+    {
+        Mat weights({inSize[0], inSize[0], 1, 1}, CV_32F);
+        randu(weights, -1.0f, 1.0f);
+
+        LayerParams convParam;
+        convParam.set("kernel_w", 1);
+        convParam.set("kernel_h", 1);
+        convParam.set("num_output", inSize[0]);
+        convParam.set("bias_term", false);
+        convParam.type = "Convolution";
+        std::ostringstream ss;
+        ss << "convLayer" << i;
+        convParam.name = ss.str();
+        convParam.blobs.push_back(weights);
+
+        int convId = net.addLayer(convParam.name, convParam.type, convParam);
+        net.connect(0, 0, convId, 0);
+        net.connect(convId, 0, eltwiseId, i + 1);
+    }
+
+    Mat input({1, inSize[0], inSize[1], inSize[2]}, CV_32F);
+    randu(input, -1.0f, 1.0f);
+
+    net.setInput(input);
+    Mat outputDefault = net.forward(eltwiseParam.name).clone();
+
+    net.setPreferableBackend(DNN_BACKEND_HALIDE);
+    Mat outputHalide = net.forward(eltwiseParam.name).clone();
+    normAssert(outputDefault, outputHalide);
+}
+
+INSTANTIATE_TEST_CASE_P(Layer_Test_Halide, Eltwise, Combine(
+/*input size*/ Values(Vec3i(1, 4, 5), Vec3i(2, 8, 6)),
+/*operation*/  Values("prod", "sum", "max"),
+/*num convs*/  Values(1, 2, 3)
+));
+#endif  // HAVE_HALIDE
+
+}  // namespace cvtest

modules/dnn/test/test_halide_nets.cpp

@@ -0,0 +1,173 @@
+// 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.
+//
+// Copyright (C) 2017, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+namespace cvtest
+{
+
+#ifdef HAVE_HALIDE
+using namespace cv;
+using namespace dnn;
+
+static void loadNet(const std::string& weights, const std::string& proto,
+                    const std::string& framework, Net* net)
+{
+    if (framework == "caffe")
+    {
+        *net = cv::dnn::readNetFromCaffe(proto, weights);
+    }
+    else if (framework == "torch")
+    {
+        *net = cv::dnn::readNetFromTorch(weights);
+    }
+    else if (framework == "tensorflow")
+    {
+        *net = cv::dnn::readNetFromTensorflow(weights);
+    }
+    else
+        CV_Error(Error::StsNotImplemented, "Unknown framework " + framework);
+}
+
+static void test(const std::string& weights, const std::string& proto,
+                 const std::string& scheduler, int inWidth, int inHeight,
+                 const std::string& outputLayer, const std::string& framework,
+                 int targetId, double l1 = 1e-5, double lInf = 1e-4)
+{
+    Mat input(inHeight, inWidth, CV_32FC3), outputDefault, outputHalide;
+    randu(input, 0.0f, 1.0f);
+
+    Net netDefault, netHalide;
+    loadNet(weights, proto, framework, &netDefault);
+    loadNet(weights, proto, framework, &netHalide);
+
+    netDefault.setInput(blobFromImage(input.clone(), 1.0f, Size(), Scalar(), false));
+    outputDefault = netDefault.forward(outputLayer).clone();
+
+    netHalide.setInput(blobFromImage(input.clone(), 1.0f, Size(), Scalar(), false));
+    netHalide.setPreferableBackend(DNN_BACKEND_HALIDE);
+    netHalide.setPreferableTarget(targetId);
+    netHalide.setHalideScheduler(scheduler);
+    outputHalide = netHalide.forward(outputLayer).clone();
+
+    normAssert(outputDefault, outputHalide, "First run", l1, lInf);
+
+    // An extra test: change input.
+    input *= 0.1f;
+    netDefault.setInput(blobFromImage(input.clone(), 1.0, Size(), Scalar(), false));
+    netHalide.setInput(blobFromImage(input.clone(), 1.0, Size(), Scalar(), false));
+
+    normAssert(outputDefault, outputHalide, "Second run", l1, lInf);
+
+    // Swap backends.
+    netHalide.setPreferableBackend(DNN_BACKEND_DEFAULT);
+    netHalide.setPreferableTarget(DNN_TARGET_CPU);
+    outputDefault = netHalide.forward(outputLayer).clone();
+
+    netDefault.setPreferableBackend(DNN_BACKEND_HALIDE);
+    netDefault.setPreferableTarget(targetId);
+    netDefault.setHalideScheduler(scheduler);
+    outputHalide = netDefault.forward(outputLayer).clone();
+
+    normAssert(outputDefault, outputHalide, "Swap backends", l1, lInf);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// CPU target
+////////////////////////////////////////////////////////////////////////////////
+TEST(Reproducibility_GoogLeNet_Halide, Accuracy)
+{
+    test(findDataFile("dnn/bvlc_googlenet.caffemodel", false),
+         findDataFile("dnn/bvlc_googlenet.prototxt", false),
+         "", 227, 227, "prob", "caffe", DNN_TARGET_CPU);
+};
+
+TEST(Reproducibility_AlexNet_Halide, Accuracy)
+{
+    test(findDataFile("dnn/bvlc_alexnet.caffemodel", false),
+         findDataFile("dnn/bvlc_alexnet.prototxt", false),
+         findDataFile("dnn/halide_scheduler_alexnet.yml", false),
+         227, 227, "prob", "caffe", DNN_TARGET_CPU);
+};
+
+TEST(Reproducibility_ResNet_50_Halide, Accuracy)
+{
+    test(findDataFile("dnn/ResNet-50-model.caffemodel", false),
+         findDataFile("dnn/ResNet-50-deploy.prototxt", false),
+         findDataFile("dnn/halide_scheduler_resnet_50.yml", false),
+         224, 224, "prob", "caffe", DNN_TARGET_CPU);
+};
+
+TEST(Reproducibility_SqueezeNet_v1_1_Halide, Accuracy)
+{
+    test(findDataFile("dnn/squeezenet_v1_1.caffemodel", false),
+         findDataFile("dnn/squeezenet_v1_1.prototxt", false),
+         findDataFile("dnn/halide_scheduler_squeezenet_v1_1.yml", false),
+         227, 227, "prob", "caffe", DNN_TARGET_CPU);
+};
+
+TEST(Reproducibility_Inception_5h_Halide, Accuracy)
+{
+    test(findDataFile("dnn/tensorflow_inception_graph.pb", false), "",
+         findDataFile("dnn/halide_scheduler_inception_5h.yml", false),
+         224, 224, "softmax2", "tensorflow", DNN_TARGET_CPU);
+};
+
+TEST(Reproducibility_ENet_Halide, Accuracy)
+{
+    test(findDataFile("dnn/Enet-model-best.net", false), "",
+         findDataFile("dnn/halide_scheduler_enet.yml", false),
+         512, 512, "l367_Deconvolution", "torch", DNN_TARGET_CPU, 2e-5, 0.15);
+};
+////////////////////////////////////////////////////////////////////////////////
+// OpenCL target
+////////////////////////////////////////////////////////////////////////////////
+TEST(Reproducibility_GoogLeNet_Halide_opencl, Accuracy)
+{
+    test(findDataFile("dnn/bvlc_googlenet.caffemodel", false),
+         findDataFile("dnn/bvlc_googlenet.prototxt", false),
+         "", 227, 227, "prob", "caffe", DNN_TARGET_OPENCL);
+};
+
+TEST(Reproducibility_AlexNet_Halide_opencl, Accuracy)
+{
+    test(findDataFile("dnn/bvlc_alexnet.caffemodel", false),
+         findDataFile("dnn/bvlc_alexnet.prototxt", false),
+         findDataFile("dnn/halide_scheduler_opencl_alexnet.yml", false),
+         227, 227, "prob", "caffe", DNN_TARGET_OPENCL);
+};
+
+TEST(Reproducibility_ResNet_50_Halide_opencl, Accuracy)
+{
+    test(findDataFile("dnn/ResNet-50-model.caffemodel", false),
+         findDataFile("dnn/ResNet-50-deploy.prototxt", false),
+         findDataFile("dnn/halide_scheduler_opencl_resnet_50.yml", false),
+         224, 224, "prob", "caffe", DNN_TARGET_OPENCL);
+};
+
+TEST(Reproducibility_SqueezeNet_v1_1_Halide_opencl, Accuracy)
+{
+    test(findDataFile("dnn/squeezenet_v1_1.caffemodel", false),
+         findDataFile("dnn/squeezenet_v1_1.prototxt", false),
+         findDataFile("dnn/halide_scheduler_opencl_squeezenet_v1_1.yml", false),
+         227, 227, "prob", "caffe", DNN_TARGET_OPENCL);
+};
+
+TEST(Reproducibility_Inception_5h_Halide_opencl, Accuracy)
+{
+    test(findDataFile("dnn/tensorflow_inception_graph.pb", false), "",
+         findDataFile("dnn/halide_scheduler_opencl_inception_5h.yml", false),
+         224, 224, "softmax2", "tensorflow", DNN_TARGET_OPENCL);
+};
+
+TEST(Reproducibility_ENet_Halide_opencl, Accuracy)
+{
+    test(findDataFile("dnn/Enet-model-best.net", false), "",
+         findDataFile("dnn/halide_scheduler_opencl_enet.yml", false),
+         512, 512, "l367_Deconvolution", "torch", DNN_TARGET_OPENCL, 2e-5, 0.14);
+};
+#endif  // HAVE_HALIDE
+
+}  // namespace cvtest

modules/dnn/test/test_layers.cpp

@@ -0,0 +1,417 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+#include <opencv2/core/ocl.hpp>
+#include <iostream>
+#include "npy_blob.hpp"
+#include <opencv2/dnn/shape_utils.hpp>
+#include <opencv2/dnn/all_layers.hpp>
+#include <opencv2/ts/ocl_test.hpp>
+
+namespace cvtest
+{
+
+using namespace cv;
+using namespace cv::dnn;
+
+template<typename TString>
+static String _tf(TString filename)
+{
+    String basetestdir = getOpenCVExtraDir();
+    size_t len = basetestdir.size();
+    if(len > 0 && basetestdir[len-1] != '/' && basetestdir[len-1] != '\\')
+        return (basetestdir + "/dnn/layers") + filename;
+    return (basetestdir + "dnn/layers/") + filename;
+}
+
+void runLayer(Ptr<Layer> layer, std::vector<Mat> &inpBlobs, std::vector<Mat> &outBlobs)
+{
+    size_t i, ninputs = inpBlobs.size();
+    std::vector<Mat> inp_(ninputs);
+    std::vector<Mat*> inp(ninputs);
+    std::vector<Mat> outp, intp;
+    std::vector<MatShape> inputs, outputs, internals;
+
+    for( i = 0; i < ninputs; i++ )
+    {
+        inp_[i] = inpBlobs[i].clone();
+        inp[i] = &inp_[i];
+        inputs.push_back(shape(inp_[i]));
+    }
+
+    layer->getMemoryShapes(inputs, 0, outputs, internals);
+    for(int i = 0; i < outputs.size(); i++)
+    {
+        outp.push_back(Mat(outputs[i], CV_32F));
+    }
+    for(int i = 0; i < internals.size(); i++)
+    {
+        intp.push_back(Mat(internals[i], CV_32F));
+    }
+
+    layer->finalize(inp, outp);
+    layer->forward(inp, outp, intp);
+
+    size_t noutputs = outp.size();
+    outBlobs.resize(noutputs);
+    for( i = 0; i < noutputs; i++ )
+        outBlobs[i] = outp[i];
+}
+
+
+void testLayerUsingCaffeModels(String basename, bool useCaffeModel = false, bool useCommonInputBlob = true)
+{
+    String prototxt = _tf(basename + ".prototxt");
+    String caffemodel = _tf(basename + ".caffemodel");
+
+    String inpfile = (useCommonInputBlob) ? _tf("blob.npy") : _tf(basename + ".input.npy");
+    String outfile = _tf(basename + ".npy");
+
+    cv::setNumThreads(cv::getNumberOfCPUs());
+
+    Net net;
+    {
+        Ptr<Importer> importer = createCaffeImporter(prototxt, (useCaffeModel) ? caffemodel : String());
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat inp = blobFromNPY(inpfile);
+    Mat ref = blobFromNPY(outfile);
+
+    net.setInput(inp, "input");
+    Mat out = net.forward("output");
+
+    normAssert(ref, out);
+}
+
+TEST(Layer_Test_Softmax, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_softmax");
+}
+
+TEST(Layer_Test_LRN_spatial, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_lrn_spatial");
+}
+
+TEST(Layer_Test_LRN_channels, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_lrn_channels");
+}
+
+TEST(Layer_Test_Convolution, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_convolution", true);
+}
+
+TEST(Layer_Test_DeConvolution, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_deconvolution", true, false);
+}
+
+TEST(Layer_Test_InnerProduct, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_inner_product", true);
+}
+
+TEST(Layer_Test_Pooling_max, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_pooling_max");
+}
+
+TEST(Layer_Test_Pooling_ave, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_pooling_ave");
+}
+
+TEST(Layer_Test_MVN, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_mvn");
+}
+
+void testReshape(const MatShape& inputShape, const MatShape& targetShape,
+                 int axis = 0, int num_axes = -1, bool reorder_dims = false,
+                 MatShape mask = MatShape())
+{
+    LayerParams params;
+    params.set("axis", axis);
+    params.set("num_axes", num_axes);
+    params.set("reorder_dims", reorder_dims);
+    if (!mask.empty())
+    {
+        params.set("dim", DictValue::arrayInt<int*>(&mask[0], mask.size()));
+    }
+
+    Mat inp(inputShape.size(), &inputShape[0], CV_32F);
+    std::vector<Mat> inpVec(1, inp);
+    std::vector<Mat> outVec, intVec;
+
+    Ptr<Layer> rl = LayerFactory::createLayerInstance("Reshape", params);
+    runLayer(rl, inpVec, outVec);
+
+    Mat& out = outVec[0];
+    MatShape shape(out.size.p, out.size.p + out.dims);
+    EXPECT_EQ(shape, targetShape);
+}
+
+TEST(Layer_Test_Reshape, Accuracy)
+{
+    {
+        int inp[] = {4, 3, 1, 2};
+        int out[] = {4, 3, 2};
+        testReshape(MatShape(inp, inp + 4), MatShape(out, out + 3), 2, 1);
+    }
+    {
+        int inp[] = {1, 128, 4, 4};
+        int out[] = {1, 2048};
+        int mask[] = {-1, 2048};
+        testReshape(MatShape(inp, inp + 4), MatShape(out, out + 2), 0, -1, true,
+                    MatShape(mask, mask + 2));
+    }
+}
+
+TEST(Layer_Test_BatchNorm, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_batch_norm", true);
+}
+
+TEST(Layer_Test_ReLU, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_relu");
+}
+
+TEST(Layer_Test_Dropout, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_dropout");
+}
+
+TEST(Layer_Test_Concat, Accuracy)
+{
+     testLayerUsingCaffeModels("layer_concat");
+}
+
+//template<typename XMat>
+//static void test_Layer_Concat()
+//{
+//    Matx21f a(1.f, 1.f), b(2.f, 2.f), c(3.f, 3.f);
+//    std::vector<Blob> res(1), src = { Blob(XMat(a)), Blob(XMat(b)), Blob(XMat(c)) };
+//    Blob ref(XMat(Matx23f(1.f, 2.f, 3.f, 1.f, 2.f, 3.f)));
+//
+//    runLayer(ConcatLayer::create(1), src, res);
+//    normAssert(ref, res[0]);
+//}
+//TEST(Layer_Concat, Accuracy)
+//{
+//    test_Layer_Concat<Mat>());
+//}
+//OCL_TEST(Layer_Concat, Accuracy)
+//{
+//    OCL_ON(test_Layer_Concat<Mat>());
+//    );
+//}
+
+static void test_Reshape_Split_Slice_layers()
+{
+    Net net;
+    {
+        Ptr<Importer> importer = createCaffeImporter(_tf("reshape_and_slice_routines.prototxt"));
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat input(6, 12, CV_32F);
+    RNG rng(0);
+    rng.fill(input, RNG::UNIFORM, -1, 1);
+
+    net.setInput(input, "input");
+    Mat output = net.forward("output");
+
+    normAssert(input, output);
+}
+TEST(Layer_Test_Reshape_Split_Slice, Accuracy)
+{
+    test_Reshape_Split_Slice_layers();
+}
+
+class Layer_LSTM_Test : public ::testing::Test
+{
+public:
+    int numInp, numOut;
+    Mat Wh, Wx, b;
+    Ptr<LSTMLayer> layer;
+    std::vector<Mat> inputs, outputs;
+
+    Layer_LSTM_Test() {}
+
+    void init(const MatShape &inpShape_, const MatShape &outShape_)
+    {
+        numInp = total(inpShape_);
+        numOut = total(outShape_);
+
+        Wh = Mat::ones(4 * numOut, numOut, CV_32F);
+        Wx = Mat::ones(4 * numOut, numInp, CV_32F);
+        b  = Mat::ones(4 * numOut, 1, CV_32F);
+
+        layer = LSTMLayer::create(LayerParams());
+        layer->setWeights(Wh, Wx, b);
+        layer->setOutShape(outShape_);
+    }
+};
+
+TEST_F(Layer_LSTM_Test, get_set_test)
+{
+    const int TN = 4;
+    MatShape inpShape = shape(5, 3, 2);
+    MatShape outShape = shape(3, 1, 2);
+    MatShape inpResShape = concat(shape(TN), inpShape);
+    MatShape outResShape = concat(shape(TN), outShape);
+
+    init(inpShape, outShape);
+    layer->setProduceCellOutput(true);
+    layer->setUseTimstampsDim(false);
+    layer->setOutShape(outShape);
+
+    Mat C((int)outResShape.size(), &outResShape[0], CV_32F);
+    randu(C, -1., 1.);
+    Mat H = C.clone();
+    randu(H, -1., 1.);
+
+    Mat inp((int)inpResShape.size(), &inpResShape[0], CV_32F);
+    randu(inp, -1., 1.);
+
+    inputs.push_back(inp);
+    runLayer(layer, inputs, outputs);
+
+    EXPECT_EQ(2u, outputs.size());
+
+    print(outResShape, "outResShape");
+    print(shape(outputs[0]), "out0");
+    print(shape(outputs[0]), "out1");
+
+    EXPECT_EQ(outResShape, shape(outputs[0]));
+    EXPECT_EQ(outResShape, shape(outputs[1]));
+
+    EXPECT_EQ(0, layer->inputNameToIndex("x"));
+    EXPECT_EQ(0, layer->outputNameToIndex("h"));
+    EXPECT_EQ(1, layer->outputNameToIndex("c"));
+}
+
+TEST(Layer_LSTM_Test_Accuracy_with_, CaffeRecurrent)
+{
+    Ptr<LSTMLayer> layer = LSTMLayer::create(LayerParams());
+
+    Mat Wx = blobFromNPY(_tf("lstm.prototxt.w_0.npy"));
+    Mat Wh = blobFromNPY(_tf("lstm.prototxt.w_2.npy"));
+    Mat b  = blobFromNPY(_tf("lstm.prototxt.w_1.npy"));
+    layer->setWeights(Wh, Wx, b);
+
+    Mat inp = blobFromNPY(_tf("recurrent.input.npy"));
+    std::vector<Mat> inputs(1, inp), outputs;
+    runLayer(layer, inputs, outputs);
+
+    Mat h_t_reference = blobFromNPY(_tf("lstm.prototxt.h_1.npy"));
+    normAssert(h_t_reference, outputs[0]);
+}
+
+TEST(Layer_RNN_Test_Accuracy_with_, CaffeRecurrent)
+{
+    Ptr<RNNLayer> layer = RNNLayer::create(LayerParams());
+
+    layer->setWeights(
+                blobFromNPY(_tf("rnn.prototxt.w_0.npy")),
+                blobFromNPY(_tf("rnn.prototxt.w_1.npy")),
+                blobFromNPY(_tf("rnn.prototxt.w_2.npy")),
+                blobFromNPY(_tf("rnn.prototxt.w_3.npy")),
+                blobFromNPY(_tf("rnn.prototxt.w_4.npy")) );
+
+    std::vector<Mat> output, input(1, blobFromNPY(_tf("recurrent.input.npy")));
+    runLayer(layer, input, output);
+
+    Mat h_ref = blobFromNPY(_tf("rnn.prototxt.h_1.npy"));
+    normAssert(h_ref, output[0]);
+}
+
+
+class Layer_RNN_Test : public ::testing::Test
+{
+public:
+    int nX, nH, nO, nT, nS;
+    Mat Whh, Wxh, bh, Who, bo;
+    Ptr<RNNLayer> layer;
+
+    std::vector<Mat> inputs, outputs;
+
+    Layer_RNN_Test()
+    {
+        nT = 3;
+        nS = 5;
+        nX = 31;
+        nH = 64;
+        nO = 100;
+
+        Whh = Mat::ones(nH, nH, CV_32F);
+        Wxh = Mat::ones(nH, nX, CV_32F);
+        bh  = Mat::ones(nH, 1, CV_32F);
+        Who = Mat::ones(nO, nH, CV_32F);
+        bo  = Mat::ones(nO, 1, CV_32F);
+
+        layer = RNNLayer::create(LayerParams());
+        layer->setProduceHiddenOutput(true);
+        layer->setWeights(Wxh, bh, Whh, Who, bo);
+    }
+};
+
+TEST_F(Layer_RNN_Test, get_set_test)
+{
+    int sz[] = { nT, nS, 1, nX };
+    Mat inp(4, sz, CV_32F);
+    randu(inp, -1., 1.);
+    inputs.push_back(inp);
+    runLayer(layer, inputs, outputs);
+
+    EXPECT_EQ(outputs.size(), 2u);
+    EXPECT_EQ(shape(outputs[0]), shape(nT, nS, nO));
+    EXPECT_EQ(shape(outputs[1]), shape(nT, nS, nH));
+}
+
+}

modules/dnn/test/test_main.cpp

@@ -0,0 +1,20 @@
+#include "test_precomp.hpp"
+
+static const char* extraTestDataPath =
+#ifdef WINRT
+        NULL;
+#else
+        getenv("OPENCV_DNN_TEST_DATA_PATH");
+#endif
+
+CV_TEST_MAIN("",
+    extraTestDataPath ? (void)cvtest::addDataSearchPath(extraTestDataPath) : (void)0
+)
+
+namespace cvtest
+{
+
+using namespace cv;
+using namespace cv::dnn;
+
+}

modules/dnn/test/test_precomp.hpp

@@ -0,0 +1,62 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef __GNUC__
+#  pragma GCC diagnostic ignored "-Wmissing-declarations"
+#  if defined __clang__ || defined __APPLE__
+#    pragma GCC diagnostic ignored "-Wmissing-prototypes"
+#    pragma GCC diagnostic ignored "-Wextra"
+#  endif
+#endif
+
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/core.hpp"
+#include "opencv2/dnn.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/ts.hpp"
+#include <opencv2/ts/ts_perf.hpp>
+#include <opencv2/core/utility.hpp>
+#include "test_common.hpp"
+
+#endif

modules/dnn/test/test_tf_importer.cpp

@@ -0,0 +1,74 @@
+// 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.
+
+// Copyright (C) 2016, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+/*
+Test for Tensorflow models loading
+*/
+
+#include "test_precomp.hpp"
+#include "npy_blob.hpp"
+
+namespace cvtest
+{
+
+using namespace cv;
+using namespace cv::dnn;
+
+template<typename TString>
+static std::string _tf(TString filename)
+{
+    return (getOpenCVExtraDir() + "/dnn/") + filename;
+}
+
+TEST(Test_TensorFlow, read_inception)
+{
+    Net net;
+    {
+        const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false);
+        Ptr<Importer> importer = createTensorflowImporter(model);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat sample = imread(_tf("grace_hopper_227.png"));
+    ASSERT_TRUE(!sample.empty());
+    Mat input;
+    resize(sample, input, Size(224, 224));
+    input -= 128; // mean sub
+
+    Mat inputBlob = blobFromImage(input);
+
+    net.setInput(inputBlob, "input");
+    Mat out = net.forward("softmax2");
+
+    std::cout << out.dims << std::endl;
+}
+
+TEST(Test_TensorFlow, inception_accuracy)
+{
+    Net net;
+    {
+        const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false);
+        Ptr<Importer> importer = createTensorflowImporter(model);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat sample = imread(_tf("grace_hopper_227.png"));
+    ASSERT_TRUE(!sample.empty());
+    resize(sample, sample, Size(224, 224));
+    Mat inputBlob = blobFromImage(sample);
+
+    net.setInput(inputBlob, "input");
+    Mat out = net.forward("softmax2");
+
+    Mat ref = blobFromNPY(_tf("tf_inception_prob.npy"));
+
+    normAssert(ref, out);
+}
+
+}

modules/dnn/test/test_torch_importer.cpp

@@ -0,0 +1,207 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifdef ENABLE_TORCH_IMPORTER
+
+#include "test_precomp.hpp"
+#include "npy_blob.hpp"
+#include <opencv2/dnn/shape_utils.hpp>
+
+namespace cvtest
+{
+
+using namespace std;
+using namespace testing;
+using namespace cv;
+using namespace cv::dnn;
+
+template<typename TStr>
+static std::string _tf(TStr filename, bool inTorchDir = true)
+{
+    String path = getOpenCVExtraDir() + "/dnn/";
+    if (inTorchDir)
+        path += "torch/";
+    path += filename;
+    return path;
+}
+
+TEST(Torch_Importer, simple_read)
+{
+    Net net;
+    Ptr<Importer> importer;
+
+    ASSERT_NO_THROW( importer = createTorchImporter(_tf("net_simple_net.txt"), false) );
+    ASSERT_TRUE( importer != NULL );
+    importer->populateNet(net);
+}
+
+static void runTorchNet(String prefix, String outLayerName = "",
+                        bool check2ndBlob = false, bool isBinary = false)
+{
+    String suffix = (isBinary) ? ".dat" : ".txt";
+
+    Net net;
+    Ptr<Importer> importer = createTorchImporter(_tf(prefix + "_net" + suffix), isBinary);
+    ASSERT_TRUE(importer != NULL);
+    importer->populateNet(net);
+
+    Mat inp, outRef;
+    ASSERT_NO_THROW( inp = readTorchBlob(_tf(prefix + "_input" + suffix), isBinary) );
+    ASSERT_NO_THROW( outRef = readTorchBlob(_tf(prefix + "_output" + suffix), isBinary) );
+
+    if (outLayerName.empty())
+        outLayerName = net.getLayerNames().back();
+
+    net.setInput(inp, "0");
+    std::vector<Mat> outBlobs;
+    net.forward(outBlobs, outLayerName);
+    normAssert(outRef, outBlobs[0]);
+
+    if (check2ndBlob)
+    {
+        Mat out2 = outBlobs[1];
+        Mat ref2 = readTorchBlob(_tf(prefix + "_output_2" + suffix), isBinary);
+        normAssert(out2, ref2);
+    }
+}
+
+TEST(Torch_Importer, run_convolution)
+{
+    runTorchNet("net_conv");
+}
+
+TEST(Torch_Importer, run_pool_max)
+{
+    runTorchNet("net_pool_max", "", true);
+}
+
+TEST(Torch_Importer, run_pool_ave)
+{
+    runTorchNet("net_pool_ave");
+}
+
+TEST(Torch_Importer, run_reshape)
+{
+    runTorchNet("net_reshape");
+    runTorchNet("net_reshape_batch");
+    runTorchNet("net_reshape_single_sample");
+}
+
+TEST(Torch_Importer, run_linear)
+{
+    runTorchNet("net_linear_2d");
+}
+
+TEST(Torch_Importer, run_paralel)
+{
+    runTorchNet("net_parallel", "l5_torchMerge");
+}
+
+TEST(Torch_Importer, run_concat)
+{
+    runTorchNet("net_concat", "l5_torchMerge");
+}
+
+TEST(Torch_Importer, run_deconv)
+{
+    runTorchNet("net_deconv");
+}
+
+TEST(Torch_Importer, run_batch_norm)
+{
+    runTorchNet("net_batch_norm");
+}
+
+TEST(Torch_Importer, net_prelu)
+{
+    runTorchNet("net_prelu");
+}
+
+TEST(Torch_Importer, net_cadd_table)
+{
+    runTorchNet("net_cadd_table");
+}
+
+TEST(Torch_Importer, net_softmax)
+{
+    runTorchNet("net_softmax");
+    runTorchNet("net_softmax_spatial");
+}
+
+TEST(Torch_Importer, net_logsoftmax)
+{
+    runTorchNet("net_logsoftmax");
+    runTorchNet("net_logsoftmax_spatial");
+}
+
+TEST(Torch_Importer, ENet_accuracy)
+{
+    Net net;
+    {
+        const string model = findDataFile("dnn/Enet-model-best.net", false);
+        Ptr<Importer> importer = createTorchImporter(model, true);
+        ASSERT_TRUE(importer != NULL);
+        importer->populateNet(net);
+    }
+
+    Mat sample = imread(_tf("street.png", false));
+    Mat inputBlob = blobFromImage(sample, 1./255);
+
+    net.setInput(inputBlob, "");
+    Mat out = net.forward();
+    Mat ref = blobFromNPY(_tf("torch_enet_prob.npy", false));
+    // Due to numerical instability in Pooling-Unpooling layers (indexes jittering)
+    // thresholds for ENet must be changed. Accuracy of resuults was checked on
+    // Cityscapes dataset and difference in mIOU with Torch is 10E-4%
+    normAssert(ref, out, "", 0.00044, 0.44);
+
+    const int N = 3;
+    for (int i = 0; i < N; i++)
+    {
+        net.setInput(inputBlob, "");
+        Mat out = net.forward();
+        normAssert(ref, out, "", 0.00044, 0.44);
+    }
+}
+
+}
+
+#endif