Chiebot-Mirror
/
opencv
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source
pull/16585/head
Alexander Alekhin 5 years ago
parent cc259e49f6 a8c257cecb
commit f3237fdc6e
7 changed files with 301 additions and 187 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      cmake/OpenCVCRTLinkage.cmake
  2. 35
      cmake/OpenCVCompilerOptions.cmake
  3. 4
      cmake/OpenCVDetectInferenceEngine.cmake
  4. 324
      modules/dnn/src/dnn.cpp
  5. 99
      modules/dnn/src/layers/elementwise_layers.cpp
  6. 9
      modules/dnn/src/op_inf_engine.hpp
  7. 8
      modules/objdetect/src/qrcode.cpp

9
cmake/OpenCVCRTLinkage.cmake
Unescape View File

@ -64,12 +64,3 @@ else()
endif()
endforeach(flag_var)
endif()
if(CMAKE_VERSION VERSION_GREATER "2.8.6")
include(ProcessorCount)
ProcessorCount(N)
if(NOT N EQUAL 0)
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP${N} ")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP${N} ")
endif()
endif()

35
cmake/OpenCVCompilerOptions.cmake
Unescape View File

@ -444,3 +444,38 @@ if(OPENCV_EXTRA_RPATH_LINK_PATH)
message(WARNING "OPENCV_EXTRA_RPATH_LINK_PATH may not work properly because CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG is not defined (not supported)")
endif()
endif()
# Control MSVC /MP flag
# Input variables: OPENCV_MSVC_PARALLEL (ON,1,2,3,...) + OPENCV_SKIP_MSVC_PARALLEL
# Details:
# - https://docs.microsoft.com/en-us/cpp/build/reference/mp-build-with-multiple-processes
# - https://docs.microsoft.com/en-us/cpp/build/reference/cl-environment-variables
# - https://gitlab.kitware.com/cmake/cmake/merge_requests/1718/diffs
if(CMAKE_GENERATOR MATCHES "Visual Studio" AND CMAKE_CXX_COMPILER_ID MATCHES "MSVC|Intel")
ocv_check_environment_variables(OPENCV_SKIP_MSVC_PARALLEL)
if(OPENCV_SKIP_MSVC_PARALLEL)
# nothing
elseif(" ${CMAKE_CXX_FLAGS}" MATCHES "/MP")
# nothing, already defined in compiler flags
elseif(DEFINED ENV{CL} AND " $ENV{CL}" MATCHES "/MP")
# nothing, compiler will use CL environment variable
elseif(DEFINED ENV{_CL_} AND " $ENV{_CL_}" MATCHES "/MP")
# nothing, compiler will use _CL_ environment variable
else()
ocv_check_environment_variables(OPENCV_MSVC_PARALLEL)
set(_mp_value "ON")
if(DEFINED OPENCV_MSVC_PARALLEL)
set(_mp_value "${OPENCV_MSVC_PARALLEL}")
endif()
set(OPENCV_MSVC_PARALLEL "${_mp_value}" CACHE STRING "Control MSVC /MP flag")
if(_mp_value)
if(_mp_value GREATER 0)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP${_mp_value}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP${_mp_value}")
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
endif()
endif()
endif()
endif()

4
cmake/OpenCVDetectInferenceEngine.cmake
Unescape View File

@ -92,9 +92,9 @@ endif()
if(INF_ENGINE_TARGET)
if(NOT INF_ENGINE_RELEASE)
message(WARNING "InferenceEngine version have not been set, 2019R3 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
message(WARNING "InferenceEngine version has not been set, 2020.1 will be used by default. Set INF_ENGINE_RELEASE variable if you experience build errors.")
endif()
set(INF_ENGINE_RELEASE "2019030000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2018R2.0.2 -> 2018020002)")
set(INF_ENGINE_RELEASE "2020010000" CACHE STRING "Force IE version, should be in form YYYYAABBCC (e.g. 2020.1.0.2 -> 2020010002)")
set_target_properties(${INF_ENGINE_TARGET} PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "HAVE_INF_ENGINE=1;INF_ENGINE_RELEASE=${INF_ENGINE_RELEASE}"
)

324
modules/dnn/src/dnn.cpp
Unescape View File

@ -68,6 +68,8 @@ namespace cv {
namespace dnn {
CV__DNN_INLINE_NS_BEGIN
static size_t DNN_NETWORK_DUMP = utils::getConfigurationParameterSizeT("OPENCV_DNN_NETWORK_DUMP", 0);
// this option is useful to run valgrind memory errors detection
static bool DNN_DISABLE_MEMORY_OPTIMIZATIONS = utils::getConfigurationParameterBool("OPENCV_DNN_DISABLE_MEMORY_OPTIMIZATIONS", false);
@ -92,6 +94,7 @@ using std::vector;
using std::map;
using std::make_pair;
using std::set;
using std::string;
//==================================================================================================
@ -1113,12 +1116,19 @@ static Ptr<BackendWrapper> wrapMat(int backendId, int targetId, cv::Mat& m)
return Ptr<BackendWrapper>(); // TODO Error?
}
static int g_networkId = 0;
struct Net::Impl
{
typedef std::map<int, LayerShapes> LayersShapesMap;
typedef std::map<int, LayerData> MapIdToLayerData;
const int networkId; // network global identifier
int networkDumpCounter; // dump counter
Impl()
: networkId(CV_XADD(&g_networkId, 1))
, networkDumpCounter(0)
{
//allocate fake net input layer
netInputLayer = Ptr<DataLayer>(new DataLayer());
@ -1326,6 +1336,11 @@ struct Net::Impl
{
CV_TRACE_FUNCTION();
if (DNN_NETWORK_DUMP > 0 && networkDumpCounter == 0)
{
dumpNetworkToFile();
}
if (preferableBackend == DNN_BACKEND_DEFAULT)
preferableBackend = (Backend)PARAM_DNN_BACKEND_DEFAULT;
#ifdef HAVE_INF_ENGINE
@ -1423,6 +1438,11 @@ struct Net::Impl
netWasAllocated = true;
this->blobsToKeep = blobsToKeep_;
if (DNN_NETWORK_DUMP > 0)
{
dumpNetworkToFile();
}
}
}
@ -3238,6 +3258,31 @@ struct Net::Impl
static
Net createNetworkFromModelOptimizer(InferenceEngine::CNNNetwork& ieNet);
#endif
string dump();
void dumpNetworkToFile()
{
#ifndef OPENCV_DNN_DISABLE_NETWORK_AUTO_DUMP
String dumpFileName = cv::format("ocv_dnn_net_%05d_%02d.dot", networkId, networkDumpCounter++);
try
{
string dumpStr = dump();
std::ofstream out(dumpFileName.c_str(), std::ios::out | std::ios::binary);
out << dumpStr;
}
catch (const std::exception& e)
{
std::ofstream out((dumpFileName + ".error").c_str(), std::ios::out);
out << "Exception: " << e.what() << std::endl;
}
catch (...)
{
std::ofstream out((dumpFileName + ".error").c_str(), std::ios::out);
out << "Can't dump: unknown exception" << std::endl;
}
#endif
}
};
Net::Net() : impl(new Net::Impl)
@ -3756,20 +3801,26 @@ int Net::getLayerId(const String &layer)
return impl->getLayerId(layer);
}
String parseLayerParams(const String& name, const LayerParams& lp) {
static
string dumpLayerParameterSize(const string& name, const LayerParams& lp)
{
std::ostringstream out(name, std::ios::ate);
DictValue param = lp.get(name);
std::ostringstream out;
out << name << " ";
switch (param.size()) {
case 1: out << ": "; break;
case 2: out << "(HxW): "; break;
case 3: out << "(DxHxW): "; break;
default: CV_Error(Error::StsNotImplemented, format("Unsupported %s size = %d", name.c_str(), param.size()));
switch (param.size())
{
case 1: out << " : "; break;
case 2: out << " (HxW): "; break;
case 3: out << " (DxHxW): "; break;
default:
CV_LOG_INFO(NULL, format("DNN/dumpLayerParameterSize(): Unsupported '%s' size = %d", name.c_str(), param.size()));
out << ": ";
}
for (size_t i = 0; i < param.size() - 1; i++) {
out << param.get<int>(i) << " x ";
for (size_t i = 0; i < param.size(); i++)
{
if (i > 0)
out << " x ";
out << param.get<int>(i);
}
out << param.get<int>(param.size() - 1) << "\\l";
return out.str();
}
@ -3777,23 +3828,33 @@ String Net::dump()
{
CV_Assert(!empty());
if (impl->netInputLayer->inputsData.empty())
CV_Error(Error::StsError, "Requested set input");
bool hasInput = !impl->netInputLayer->inputsData.empty();
if (hasInput)
{
if (!impl->netWasAllocated)
impl->setUpNet();
}
return impl->dump();
}
if (!impl->netWasAllocated)
impl->setUpNet();
string Net::Impl::dump()
{
bool hasInput = !netInputLayer->inputsData.empty();
std::ostringstream out;
std::map<int, LayerData>& map = impl->layers;
int prefBackend = impl->preferableBackend;
const std::map<int, LayerData>& map = layers;
Backend prefBackend = (Backend)preferableBackend;
std::vector<std::vector<int> > skippedLayers;
std::vector<int> skipId;
std::vector<int> allLayers(map.size(), -1);
int idPrev = -1;
Ptr<BackendNode> prevNode;
for (std::map<int, LayerData>::reverse_iterator rit = map.rbegin(); rit != map.rend(); ++rit)
for (std::map<int, LayerData>::const_reverse_iterator rit = map.rbegin(); rit != map.rend(); ++rit)
{
std::map<int, Ptr<BackendNode> >::iterator itBackend = rit->second.backendNodes.find(prefBackend);
std::map<int, Ptr<BackendNode> >::const_iterator itBackend = rit->second.backendNodes.find(prefBackend);
if (prefBackend == DNN_BACKEND_OPENCV || itBackend == rit->second.backendNodes.end() ||
itBackend->second.empty())
{
@ -3832,157 +3893,208 @@ String Net::dump()
prevNode = itBackend->second;
}
}
String colors[] = {"#ffffb3", "#fccde5", "#8dd3c7", "#bebada", "#80b1d3", "#fdb462", "#ff4848"};
String backend;
switch (prefBackend) {
string colors[] = {"#ffffb3", "#fccde5", "#8dd3c7", "#bebada", "#80b1d3", "#fdb462", "#ff4848", "#b35151"};
string backend;
switch (prefBackend)
{
case DNN_BACKEND_DEFAULT: backend = "DEFAULT/"; break;
case DNN_BACKEND_HALIDE: backend = "HALIDE/"; break;
case DNN_BACKEND_INFERENCE_ENGINE: // fallthru
case DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019: backend = "DLIE/"; break;
case DNN_BACKEND_INFERENCE_ENGINE_NGRAPH: backend = "NGRAPH/"; break;
case DNN_BACKEND_OPENCV: backend = "OCV/"; break;
case DNN_BACKEND_VKCOM: backend = "VULKAN/"; break;
case DNN_BACKEND_CUDA: backend = "CUDA/"; break;
// don't use default:
}
out << "digraph G {" << '\n';
out << "digraph G {\n";
// Add nodes
for (std::map<int, LayerData>::iterator it = map.begin(); it != map.end(); ++it)
for (std::map<int, LayerData>::const_iterator it = map.begin(); it != map.end(); ++it)
{
String name = it->second.params.name;
if (allLayers[it->first] == -1 && !name.empty()) {
out << " " << "\"" << name << "\"" << " [label=\"";
skipId.clear();
skipId.push_back(it->first);
const LayerData& ld = it->second;
string name = ld.params.name;
std::vector<int> clusterIds(1, it->first);
if (allLayers[it->first] == -1 && !name.empty())
{
out << "\t\"" << name << "\" [label=\"";
}
else if (name.empty() || it->first != skippedLayers[allLayers[it->first]][0])
{
continue;
else { // first node in cluster : it->first == skippedLayers[allLayers[it->first]][0]
}
else // first node in cluster : it->first == skippedLayers[allLayers[it->first]][0]
{
int cluster = allLayers[it->first];
out << " " << "\"" << "cluster_" << cluster << "\"" << " [label=\"{";
skipId = skippedLayers[allLayers[it->first]]; // vertices in current cluster
out << "\t\"" << "cluster_" << cluster << "\" [label=\"{";
clusterIds = skippedLayers[allLayers[it->first]]; // vertices in current cluster
}
for (int i = 0; i < skipId.size(); i++)
for (int i = 0; i < clusterIds.size(); i++)
{
LayerParams& lp = map[skipId[i]].params;
CV_DbgAssert(map.find(clusterIds[i]) != map.end());
const LayerParams& lp = map.find(clusterIds[i])->second.params;
if (!lp.name.empty()) {
if (i > 0) {
out << " | ";
}
out << lp.name << "\\n" << lp.type << "\\n";
if (lp.has("kernel_size")) {
String kernel = parseLayerParams("kernel_size", lp);
out << lp.name << "\\n" << lp.type << "\\n"; // align center
if (lp.has("kernel_size"))
{
string kernel = dumpLayerParameterSize("kernel_size", lp);
out << kernel;
out << "\\l"; // align left
} else if (lp.has("kernel_h") && lp.has("kernel_w")) {
DictValue h = lp.get("kernel_h");
DictValue w = lp.get("kernel_w");
out << "kernel (HxW): " << h << " x " << w << "\\l";
out << "kernel (HxW): " << h << " x " << w;
out << "\\l"; // align left
}
if (lp.has("stride")) {
String stride = parseLayerParams("stride", lp);
string stride = dumpLayerParameterSize("stride", lp);
out << stride;
out << "\\l"; // align left
} else if (lp.has("stride_h") && lp.has("stride_w")) {
DictValue h = lp.get("stride_h");
DictValue w = lp.get("stride_w");
out << "stride (HxW): " << h << " x " << w << "\\l";
out << "stride (HxW): " << h << " x " << w;
out << "\\l"; // align left
}
if (lp.has("dilation")) {
String dilation = parseLayerParams("dilation", lp);
string dilation = dumpLayerParameterSize("dilation", lp);
out << dilation;
out << "\\l"; // align left
} else if (lp.has("dilation_h") && lp.has("dilation_w")) {
DictValue h = lp.get("dilation_h");
DictValue w = lp.get("dilation_w");
out << "dilation (HxW): " << h << " x " << w << "\\l";
out << "dilation (HxW): " << h << " x " << w;
out << "\\l"; // align left
}
if (lp.has("pad")) {
DictValue pad = lp.get("pad");
out << "pad ";
switch (pad.size()) {
case 1: out << ": " << pad << "\\l"; break;
case 2: out << "(HxW): (" << pad.get<int>(0) << " x " << pad.get<int>(1) << ")" << "\\l"; break;
case 4: out << "(HxW): (" << pad.get<int>(0) << ", " << pad.get<int>(2) << ") x (" << pad.get<int>(1) << ", " << pad.get<int>(3) << ")" << "\\l"; break;
case 6: out << "(DxHxW): (" << pad.get<int>(0) << ", " << pad.get<int>(3) << ") x (" << pad.get<int>(1) << ", " << pad.get<int>(4)
<< ") x (" << pad.get<int>(2) << ", " << pad.get<int>(5) << ")" << "\\l"; break;
switch (pad.size())
{
case 1: out << ": " << pad; break;
case 2:
out << "(HxW): (" << pad.get<int>(0) << " x " << pad.get<int>(1) << ")";
break;
case 4:
out << "(HxW): (" << pad.get<int>(0) << ", " << pad.get<int>(2)
<< ") x (" << pad.get<int>(1) << ", " << pad.get<int>(3) << ")";
break;
case 6:
out << "(DxHxW): (" << pad.get<int>(0) << ", " << pad.get<int>(3)
<< ") x (" << pad.get<int>(1) << ", " << pad.get<int>(4)
<< ") x (" << pad.get<int>(2) << ", " << pad.get<int>(5) << ")";
break;
default: CV_Error(Error::StsNotImplemented, format("Unsupported pad size = %d", pad.size()));
}
} else if (lp.has("pad_l") && lp.has("pad_t") && lp.has("pad_r") && lp.has("pad_b")) {
DictValue l = lp.get("pad_l");
DictValue t = lp.get("pad_t");
DictValue r = lp.get("pad_r");
DictValue b = lp.get("pad_b");
out << "pad (HxW): (" << t << ", " << b << ") x (" << l << ", " << r << ")" << "\\l";
}
else if (lp.has("pooled_w") || lp.has("pooled_h")) {
DictValue h = lp.get("pooled_h");
DictValue w = lp.get("pooled_w");
out << "pad (HxW): " << h << " x " << w << "\\l";
}
if (lp.has("pool")) {
out << "pool: " << lp.get("pool") << "\\l";
}
if (lp.has("global_pooling")) {
out << "global_pooling: " << lp.get("global_pooling") << "\\l";
}
if (lp.has("group")) {
out << "group: " << lp.get("group") << "\\l";
}
}
}
if (!it->second.outputBlobs.empty())
out << "output: " << it->second.outputBlobs[0].size << "\\l";
Ptr<BackendNode> layerBackend = it->second.backendNodes[prefBackend];
out << (!layerBackend.empty() ? backend : "OCV/");
int colorId = 0;
switch (it->second.layerInstance->preferableTarget) {
case DNN_TARGET_CPU: out << "CPU\\n"; colorId = layerBackend.empty() ? 0 : 5; break;
case DNN_TARGET_OPENCL: out << "OCL\\n"; colorId = 1; break;
case DNN_TARGET_OPENCL_FP16: out << "OCL_FP16\\n"; colorId = 2; break;
case DNN_TARGET_MYRIAD: out << "MYRIAD\\n"; colorId = 3; break;
case DNN_TARGET_FPGA: out << "FPGA\\n"; colorId = 4; break;
case DNN_TARGET_CUDA: out << "CUDA\\n"; colorId = 5; break;
case DNN_TARGET_CUDA_FP16: out << "CUDA_FP16\\n"; colorId = 6; break;
}
out << ((skipId.size() == 1)? "\" " : " }\" ");
out << "fillcolor=\"" << colors[colorId] << "\" ";
out << "style=filled ";
out << "shape=" << ((skipId.size() == 1)? "box" : "record") << "]" << '\n';
out << "\\l"; // align left
} else if (lp.has("pad_l") && lp.has("pad_t") && lp.has("pad_r") && lp.has("pad_b")) {
DictValue l = lp.get("pad_l");
DictValue t = lp.get("pad_t");
DictValue r = lp.get("pad_r");
DictValue b = lp.get("pad_b");
out << "pad (HxW): (" << t << ", " << b << ") x (" << l << ", " << r << ")";
out << "\\l"; // align left
}
else if (lp.has("pooled_w") || lp.has("pooled_h")) {
DictValue h = lp.get("pooled_h");
DictValue w = lp.get("pooled_w");
out << "pad pooled (HxW): " << h << " x " << w;
out << "\\l"; // align left
}
if (lp.has("pool")) {
out << "pool: " << lp.get("pool");
out << "\\l"; // align left
}
if (lp.has("global_pooling")) {
out << "global_pooling: " << lp.get("global_pooling");
out << "\\l"; // align left
}
if (lp.has("group")) {
out << "group: " << lp.get("group");
out << "\\l"; // align left
}
}
}
if (!ld.outputBlobs.empty())
{
out << "output: " << ld.outputBlobs[0].size;
out << "\\l"; // align left
}
Ptr<BackendNode> layerBackend;
std::map<int, Ptr<BackendNode> >::const_iterator ibn = ld.backendNodes.find(prefBackend);
if (ibn != ld.backendNodes.end())
layerBackend = ibn->second;
out << (!layerBackend.empty() ? backend : "OCV/");
int colorId = 0;
const Target target = ld.layerInstance.empty()
? DNN_TARGET_CPU
: (Target)(ld.layerInstance->preferableTarget); // TODO fix preferableTarget type
switch (target)
{
case DNN_TARGET_CPU: out << "CPU"; colorId = layerBackend.empty() ? 0 : 5; break;
case DNN_TARGET_OPENCL: out << "OCL"; colorId = 1; break;
case DNN_TARGET_OPENCL_FP16: out << "OCL_FP16"; colorId = 2; break;
case DNN_TARGET_MYRIAD: out << "MYRIAD"; colorId = 3; break;
case DNN_TARGET_VULKAN: out << "VULKAN"; colorId = 7; break;
case DNN_TARGET_FPGA: out << "FPGA"; colorId = 4; break;
case DNN_TARGET_CUDA: out << "CUDA"; colorId = 5; break;
case DNN_TARGET_CUDA_FP16: out << "CUDA_FP16"; colorId = 6; break;
// don't use default:
}
out << "\\n"; // align center
out << ((clusterIds.size() == 1)? "\" " : " }\" ");
out << "fillcolor=\"" << colors[colorId] << "\" ";
out << "style=filled ";
out << "shape=" << ((clusterIds.size() == 1)? "box" : "record") << "]\n";
}
out << '\n';
// Add edges
int inputsSize = impl->netInputLayer->outNames.size();
for (std::map<int, LayerData>::iterator it = map.begin(); it != map.end(); ++it)
int inputsSize = hasInput ? netInputLayer->outNames.size() : 0;
for (std::map<int, LayerData>::const_iterator it = map.begin(); it != map.end(); ++it)
{
const LayerData& ld = it->second;
if (allLayers[it->first] == -1) // node
{
for (int i = 0; i < it->second.consumers.size(); i++)
for (int i = 0; i < ld.consumers.size(); i++)
{
int outId = it->second.consumers[i].lid;
int outId = ld.consumers[i].lid;
if (it == map.begin() && inputsSize > 1)
out << " " << "\"" << it->second.name << "_" << i << "\"" << " -> ";
out << "\t\"" << ld.name << "_" << i << "\"" << " -> ";
else
out << " " << "\"" << it->second.name << "\"" << " -> ";
out << "\t\"" << ld.name << "\"" << " -> ";
if (allLayers[outId] == -1) // node
out << "\"" << map[outId].name << "\"" << '\n';
{
CV_DbgAssert(map.find(outId) != map.end());
out << "\"" << map.find(outId)->second.name << "\"\n";
}
else // cluster
out << "\"" << "cluster_" << allLayers[outId] << "\"" << '\n';
{
out << "\"" << "cluster_" << allLayers[outId] << "\"\n";
}
}
}
else if (it->first == skippedLayers[allLayers[it->first]].back()) // edges from last layer in cluster
{
for (int i = 0; i < it->second.consumers.size(); i++)
for (int i = 0; i < ld.consumers.size(); i++)
{
int outId = it->second.consumers[i].lid;
if (allLayers[outId] == -1) { // node
out << " " << "\"" << "cluster_" << allLayers[it->first] << "\"" << " -> ";
out << "\"" << map[outId].name << "\"" << '\n';
int outId = ld.consumers[i].lid;
if (allLayers[outId] == -1) // node
{
CV_DbgAssert(map.find(outId) != map.end());
out << "\t\"" << "cluster_" << allLayers[it->first] << "\"" << " -> ";
out << "\"" << map.find(outId)->second.name << "\"\n";
}
else if (allLayers[outId] != allLayers[it->first]) { // another cluster
out << " " << "\"" << "cluster_" << allLayers[it->first] << "\"" << " -> ";
out << "\"" << "cluster_" << allLayers[outId] << "\"" << '\n';
out << "\t\"" << "cluster_" << allLayers[it->first] << "\"" << " -> ";
out << "\"" << "cluster_" << allLayers[outId] << "\"\n";
}
}
}
}
out << "}";
out << "}\n";
return out.str();
}

99
modules/dnn/src/layers/elementwise_layers.cpp
Unescape View File

@ -119,13 +119,18 @@ public:
}
};
ElementWiseLayer(const Func &f=Func()) : run_parallel(false) { func = f; }
ElementWiseLayer(const Func &f=Func()) { func = f; }
virtual bool supportBackend(int backendId) CV_OVERRIDE
{
return func.supportBackend(backendId, this->preferableTarget);
}
virtual void finalize(InputArrayOfArrays, OutputArrayOfArrays) CV_OVERRIDE
{
func.finalize();
}
virtual Ptr<BackendNode> tryAttach(const Ptr<BackendNode>& node) CV_OVERRIDE
{
switch (node->backendId)
@ -262,7 +267,6 @@ public:
}
Func func;
bool run_parallel;
};
#ifdef HAVE_OPENCL
@ -277,7 +281,16 @@ static String oclGetTMacro(const UMat &m)
}
#endif
struct ReLUFunctor
struct BaseFunctor
{
void finalize() {}
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
};
struct ReLUFunctor : public BaseFunctor
{
typedef ReLULayer Layer;
float slope;
@ -421,14 +434,10 @@ struct ReLUFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 1; }
};
struct ReLU6Functor
struct ReLU6Functor : public BaseFunctor
{
typedef ReLU6Layer Layer;
float minValue, maxValue;
@ -548,14 +557,10 @@ struct ReLU6Functor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 2; }
};
struct TanHFunctor
struct TanHFunctor : public BaseFunctor
{
typedef TanHLayer Layer;
@ -644,14 +649,10 @@ struct TanHFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 1; }
};
struct SwishFunctor
struct SwishFunctor : public BaseFunctor
{
typedef SwishLayer Layer;
@ -740,15 +741,10 @@ struct SwishFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 3; }
};
struct MishFunctor
struct MishFunctor : public BaseFunctor
{
typedef MishLayer Layer;
@ -842,15 +838,10 @@ struct MishFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 3; }
};
struct SigmoidFunctor
struct SigmoidFunctor : public BaseFunctor
{
typedef SigmoidLayer Layer;
@ -939,19 +930,13 @@ struct SigmoidFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 3; }
};
struct ELUFunctor
struct ELUFunctor : public BaseFunctor
{
typedef ELULayer Layer;
explicit ELUFunctor() {}
bool supportBackend(int backendId, int)
{
return backendId == DNN_BACKEND_OPENCV ||
@ -1037,14 +1022,10 @@ struct ELUFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 2; }
};
struct AbsValFunctor
struct AbsValFunctor : public BaseFunctor
{
typedef AbsLayer Layer;
@ -1139,14 +1120,10 @@ struct AbsValFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 1; }
};
struct BNLLFunctor
struct BNLLFunctor : public BaseFunctor
{
typedef BNLLLayer Layer;
@ -1236,23 +1213,19 @@ struct BNLLFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 5; }
};
struct PowerFunctor
struct PowerFunctor : public BaseFunctor
{
typedef PowerLayer Layer;
float power;
float scale;
float shift;
float power, scale, shift;
float originPower, originScale, originShift;
explicit PowerFunctor(float power_ = 1.f, float scale_ = 1.f, float shift_ = 0.f)
: power(power_), scale(scale_), shift(shift_) {}
: power(power_), scale(scale_), shift(shift_),
originPower(power_), originScale(scale_), originShift(shift_) {}
bool supportBackend(int backendId, int targetId)
{
@ -1266,6 +1239,13 @@ struct PowerFunctor
backendId == DNN_BACKEND_HALIDE;
}
void finalize()
{
power = originPower;
scale = originScale;
shift = originShift;
}
void apply(const float* srcptr, float* dstptr, int len, size_t planeSize, int cn0, int cn1) const
{
float a = scale, b = shift, p = power;
@ -1410,8 +1390,7 @@ struct PowerFunctor
int64 getFLOPSPerElement() const { return power == 1 ? 2 : 10; }
};
struct ChannelsPReLUFunctor
struct ChannelsPReLUFunctor : public BaseFunctor
{
typedef ChannelsPReLULayer Layer;
Mat scale;
@ -1545,10 +1524,6 @@ struct ChannelsPReLUFunctor
}
#endif // HAVE_VULKAN
bool tryFuse(Ptr<dnn::Layer>&) { return false; }
void getScaleShift(Mat&, Mat&) const {}
int64 getFLOPSPerElement() const { return 1; }
};

9
modules/dnn/src/op_inf_engine.hpp
Unescape View File

@ -23,10 +23,11 @@
#define INF_ENGINE_RELEASE_2019R1 2019010000
#define INF_ENGINE_RELEASE_2019R2 2019020000
#define INF_ENGINE_RELEASE_2019R3 2019030000
#define INF_ENGINE_RELEASE_2020_1 2020010000
#ifndef INF_ENGINE_RELEASE
#warning("IE version have not been provided via command-line. Using 2019R3 by default")
#define INF_ENGINE_RELEASE INF_ENGINE_RELEASE_2019R3
#warning("IE version have not been provided via command-line. Using 2019.1 by default")
#define INF_ENGINE_RELEASE INF_ENGINE_RELEASE_2020_1
#endif
#define INF_ENGINE_VER_MAJOR_GT(ver) (((INF_ENGINE_RELEASE) / 10000) > ((ver) / 10000))
@ -49,7 +50,7 @@
#pragma warning(disable: 4996) // was declared deprecated
#endif
#if defined(__GNUC__)
#if defined(__GNUC__) && INF_ENGINE_VER_MAJOR_LT(INF_ENGINE_RELEASE_2020_1)
#pragma GCC visibility push(default)
#endif
@ -57,7 +58,7 @@
#include <ie_builders.hpp>
#if defined(__GNUC__)
#if defined(__GNUC__) && INF_ENGINE_VER_MAJOR_LT(INF_ENGINE_RELEASE_2020_1)
#pragma GCC visibility pop
#endif

8
modules/objdetect/src/qrcode.cpp
Unescape View File

@ -1297,7 +1297,7 @@ protected:
{
public:
ParallelSearch(vector< vector< Point2f > >& true_points_group_,
vector< vector< Point2f > >& loc_, int iter_, int* end_,
vector< vector< Point2f > >& loc_, int iter_, vector<int>& end_,
vector< vector< Vec3i > >& all_points_,
QRDetectMulti& cl_)
:
@ -1313,7 +1313,7 @@ protected:
vector< vector< Point2f > >& true_points_group;
vector< vector< Point2f > >& loc;
int iter;
int* end;
vector<int>& end;
vector< vector< Vec3i > >& all_points;
QRDetectMulti& cl;
};
@ -1925,7 +1925,7 @@ bool QRDetectMulti::checkSets(vector<vector<Point2f> >& true_points_group, vecto
return false;
int* set_size = new int[true_points_group.size()];
vector<int> set_size(true_points_group.size());
for (size_t i = 0; i < true_points_group.size(); i++)
{
set_size[i] = int(0.5 * (true_points_group[i].size() - 2 ) * (true_points_group[i].size() - 1));
@ -1963,7 +1963,7 @@ bool QRDetectMulti::checkSets(vector<vector<Point2f> >& true_points_group, vecto
transformation_points.resize(iter + true_points_group.size());
true_points_group_copy = true_points_group;
int* end = new int[true_points_group.size()];
vector<int> end(true_points_group.size());
for (size_t i = 0; i < true_points_group.size(); i++)
end[i] = iter + set_size[i];
ParallelSearch parallelSearch(true_points_group,

Write Preview
Loading…
Cancel
Save