mirror of https://github.com/opencv/opencv.git
Alexander Alekhin
6 years ago
commit
e6171d17f8
40 changed files with 705 additions and 404 deletions
@ -1,199 +0,0 @@ |
||||
# ----- Find Matlab/Octave ----- |
||||
# |
||||
# OpenCVFindMatlab.cmake attempts to locate the install path of Matlab in order |
||||
# to extract the mex headers, libraries and shell scripts. If found |
||||
# successfully, the following variables will be defined |
||||
# |
||||
# MATLAB_FOUND: true/false |
||||
# MATLAB_ROOT_DIR: Root of Matlab installation |
||||
# MATLAB_BIN: The main Matlab "executable" (shell script) |
||||
# MATLAB_MEX_SCRIPT: The mex script used to compile mex files |
||||
# MATLAB_INCLUDE_DIRS:Path to "mex.h" |
||||
# MATLAB_LIBRARY_DIRS:Path to mex and matrix libraries |
||||
# MATLAB_LIBRARIES: The Matlab libs, usually mx, mex, mat |
||||
# MATLAB_MEXEXT: The mex library extension. It will be one of: |
||||
# mexwin32, mexwin64, mexglx, mexa64, mexmac, |
||||
# mexmaci, mexmaci64, mexsol, mexs64 |
||||
# MATLAB_ARCH: The installation architecture. It is **usually** |
||||
# the MEXEXT with the preceding "mex" removed, |
||||
# though it's different for linux distros. |
||||
# |
||||
# There doesn't appear to be an elegant way to detect all versions of Matlab |
||||
# across different platforms. If you know the matlab path and want to avoid |
||||
# the search, you can define the path to the Matlab root when invoking cmake: |
||||
# |
||||
# cmake -DMATLAB_ROOT_DIR='/PATH/TO/ROOT_DIR' .. |
||||
|
||||
|
||||
|
||||
# ----- set_library_presuffix ----- |
||||
# |
||||
# Matlab tends to use some non-standard prefixes and suffixes on its libraries. |
||||
# For example, libmx.dll on Windows (Windows does not add prefixes) and |
||||
# mkl.dylib on OS X (OS X uses "lib" prefixes). |
||||
# On some versions of Windows the .dll suffix also appears to not be checked. |
||||
# |
||||
# This function modifies the library prefixes and suffixes used by |
||||
# find_library when finding Matlab libraries. It does not affect scopes |
||||
# outside of this file. |
||||
function(set_libarch_prefix_suffix) |
||||
if (UNIX AND NOT APPLE) |
||||
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" PARENT_SCOPE) |
||||
set(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a" PARENT_SCOPE) |
||||
elseif (APPLE) |
||||
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" PARENT_SCOPE) |
||||
set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".a" PARENT_SCOPE) |
||||
elseif (WIN32) |
||||
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" PARENT_SCOPE) |
||||
set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll" PARENT_SCOPE) |
||||
endif() |
||||
endfunction() |
||||
|
||||
|
||||
|
||||
# ----- locate_matlab_root ----- |
||||
# |
||||
# Attempt to find the path to the Matlab installation. If successful, sets |
||||
# the absolute path in the variable MATLAB_ROOT_DIR |
||||
function(locate_matlab_root) |
||||
|
||||
# --- UNIX/APPLE --- |
||||
if (UNIX) |
||||
# possible root locations, in order of likelihood |
||||
set(SEARCH_DIRS_ /Applications /usr/local /opt/local /usr /opt) |
||||
foreach (DIR_ ${SEARCH_DIRS_}) |
||||
file(GLOB MATLAB_ROOT_DIR_ ${DIR_}/MATLAB/R* ${DIR_}/MATLAB_R*) |
||||
if (MATLAB_ROOT_DIR_) |
||||
# sort in order from highest to lowest |
||||
# normally it's in the format MATLAB_R[20XX][A/B] |
||||
# TODO: numerical rather than lexicographic sort. However, |
||||
# CMake does not support floating-point MATH(EXPR ...) at this time. |
||||
list(SORT MATLAB_ROOT_DIR_) |
||||
list(REVERSE MATLAB_ROOT_DIR_) |
||||
list(GET MATLAB_ROOT_DIR_ 0 MATLAB_ROOT_DIR_) |
||||
set(MATLAB_ROOT_DIR ${MATLAB_ROOT_DIR_} PARENT_SCOPE) |
||||
return() |
||||
endif() |
||||
endforeach() |
||||
|
||||
# --- WINDOWS --- |
||||
elseif (WIN32) |
||||
# 1. search the path environment variable |
||||
find_program(MATLAB_ROOT_DIR_ matlab PATHS ENV PATH) |
||||
if (MATLAB_ROOT_DIR_) |
||||
# get the root directory from the full path |
||||
# /path/to/matlab/rootdir/bin/matlab.exe |
||||
get_filename_component(MATLAB_ROOT_DIR_ ${MATLAB_ROOT_DIR_} PATH) |
||||
get_filename_component(MATLAB_ROOT_DIR_ ${MATLAB_ROOT_DIR_} PATH) |
||||
set(MATLAB_ROOT_DIR ${MATLAB_ROOT_DIR_} PARENT_SCOPE) |
||||
return() |
||||
endif() |
||||
|
||||
# 2. search the registry |
||||
# determine the available Matlab versions |
||||
set(REG_EXTENSION_ "SOFTWARE\\Mathworks\\MATLAB") |
||||
set(REG_ROOTS_ "HKEY_LOCAL_MACHINE" "HKEY_CURRENT_USER") |
||||
foreach(REG_ROOT_ ${REG_ROOTS_}) |
||||
execute_process(COMMAND reg query "${REG_ROOT_}\\${REG_EXTENSION_}" OUTPUT_VARIABLE QUERY_RESPONSE_ ERROR_VARIABLE UNUSED_) |
||||
if (QUERY_RESPONSE_) |
||||
string(REGEX MATCHALL "[0-9]\\.[0-9]" VERSION_STRINGS_ ${QUERY_RESPONSE_}) |
||||
list(APPEND VERSIONS_ ${VERSION_STRINGS_}) |
||||
endif() |
||||
endforeach() |
||||
|
||||
# select the highest version |
||||
list(APPEND VERSIONS_ "0.0") |
||||
list(SORT VERSIONS_) |
||||
list(REVERSE VERSIONS_) |
||||
list(GET VERSIONS_ 0 VERSION_) |
||||
|
||||
# request the MATLABROOT from the registry |
||||
foreach(REG_ROOT_ ${REG_ROOTS_}) |
||||
get_filename_component(QUERY_RESPONSE_ [${REG_ROOT_}\\${REG_EXTENSION_}\\${VERSION_};MATLABROOT] ABSOLUTE) |
||||
if (NOT ${QUERY_RESPONSE_} MATCHES "registry$") |
||||
set(MATLAB_ROOT_DIR ${QUERY_RESPONSE_} PARENT_SCOPE) |
||||
return() |
||||
endif() |
||||
endforeach() |
||||
endif() |
||||
endfunction() |
||||
|
||||
|
||||
|
||||
# ----- locate_matlab_components ----- |
||||
# |
||||
# Given a directory MATLAB_ROOT_DIR, attempt to find the Matlab components |
||||
# (include directory and libraries) under the root. If everything is found, |
||||
# sets the variable MATLAB_FOUND to TRUE |
||||
function(locate_matlab_components MATLAB_ROOT_DIR) |
||||
# get the mex extension |
||||
find_file(MATLAB_MEXEXT_SCRIPT_ NAMES mexext mexext.bat PATHS ${MATLAB_ROOT_DIR}/bin NO_DEFAULT_PATH) |
||||
execute_process(COMMAND ${MATLAB_MEXEXT_SCRIPT_} |
||||
OUTPUT_VARIABLE MATLAB_MEXEXT_ |
||||
OUTPUT_STRIP_TRAILING_WHITESPACE) |
||||
if (NOT MATLAB_MEXEXT_) |
||||
return() |
||||
endif() |
||||
|
||||
# map the mexext to an architecture extension |
||||
set(ARCHITECTURES_ "maci64" "maci" "glnxa64" "glnx64" "sol64" "sola64" "win32" "win64" ) |
||||
foreach(ARCHITECTURE_ ${ARCHITECTURES_}) |
||||
if(EXISTS ${MATLAB_ROOT_DIR}/bin/${ARCHITECTURE_}) |
||||
set(MATLAB_ARCH_ ${ARCHITECTURE_}) |
||||
break() |
||||
endif() |
||||
endforeach() |
||||
|
||||
# get the path to the libraries |
||||
set(MATLAB_LIBRARY_DIRS_ ${MATLAB_ROOT_DIR}/bin/${MATLAB_ARCH_}) |
||||
|
||||
# get the libraries |
||||
set_libarch_prefix_suffix() |
||||
find_library(MATLAB_LIB_MX_ mx PATHS ${MATLAB_LIBRARY_DIRS_} NO_DEFAULT_PATH) |
||||
find_library(MATLAB_LIB_MEX_ mex PATHS ${MATLAB_LIBRARY_DIRS_} NO_DEFAULT_PATH) |
||||
find_library(MATLAB_LIB_MAT_ mat PATHS ${MATLAB_LIBRARY_DIRS_} NO_DEFAULT_PATH) |
||||
set(MATLAB_LIBRARIES_ ${MATLAB_LIB_MX_} ${MATLAB_LIB_MEX_} ${MATLAB_LIB_MAT_}) |
||||
|
||||
# get the include path |
||||
find_path(MATLAB_INCLUDE_DIRS_ mex.h ${MATLAB_ROOT_DIR}/extern/include) |
||||
|
||||
# get the mex shell script |
||||
find_program(MATLAB_MEX_SCRIPT_ NAMES mex mex.bat PATHS ${MATLAB_ROOT_DIR}/bin NO_DEFAULT_PATH) |
||||
|
||||
# get the Matlab executable |
||||
find_program(MATLAB_BIN_ NAMES matlab PATHS ${MATLAB_ROOT_DIR}/bin NO_DEFAULT_PATH) |
||||
|
||||
# export into parent scope |
||||
if (MATLAB_MEX_SCRIPT_ AND MATLAB_LIBRARIES_ AND MATLAB_INCLUDE_DIRS_) |
||||
set(MATLAB_BIN ${MATLAB_BIN_} PARENT_SCOPE) |
||||
set(MATLAB_MEX_SCRIPT ${MATLAB_MEX_SCRIPT_} PARENT_SCOPE) |
||||
set(MATLAB_INCLUDE_DIRS ${MATLAB_INCLUDE_DIRS_} PARENT_SCOPE) |
||||
set(MATLAB_LIBRARIES ${MATLAB_LIBRARIES_} PARENT_SCOPE) |
||||
set(MATLAB_LIBRARY_DIRS ${MATLAB_LIBRARY_DIRS_} PARENT_SCOPE) |
||||
set(MATLAB_MEXEXT ${MATLAB_MEXEXT_} PARENT_SCOPE) |
||||
set(MATLAB_ARCH ${MATLAB_ARCH_} PARENT_SCOPE) |
||||
endif() |
||||
endfunction() |
||||
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------- |
||||
# FIND MATLAB COMPONENTS |
||||
# ---------------------------------------------------------------------------- |
||||
if (NOT MATLAB_FOUND) |
||||
|
||||
# attempt to find the Matlab root folder |
||||
if (NOT MATLAB_ROOT_DIR) |
||||
locate_matlab_root() |
||||
endif() |
||||
|
||||
# given the matlab root folder, find the library locations |
||||
if (MATLAB_ROOT_DIR) |
||||
locate_matlab_components(${MATLAB_ROOT_DIR}) |
||||
endif() |
||||
find_package_handle_standard_args(Matlab DEFAULT_MSG |
||||
MATLAB_MEX_SCRIPT MATLAB_INCLUDE_DIRS |
||||
MATLAB_ROOT_DIR MATLAB_LIBRARIES |
||||
MATLAB_LIBRARY_DIRS MATLAB_MEXEXT |
||||
MATLAB_ARCH MATLAB_BIN) |
||||
endif() |
||||
@ -0,0 +1,91 @@ |
||||
Anisotropic image segmentation by a gradient structure tensor {#tutorial_anisotropic_image_segmentation_by_a_gst} |
||||
========================== |
||||
|
||||
Goal |
||||
---- |
||||
|
||||
In this tutorial you will learn: |
||||
|
||||
- what the gradient structure tensor is |
||||
- how to estimate orientation and coherency of an anisotropic image by a gradient structure tensor |
||||
- how to segment an anisotropic image with a single local orientation by a gradient structure tensor |
||||
|
||||
Theory |
||||
------ |
||||
|
||||
@note The explanation is based on the books @cite jahne2000computer, @cite bigun2006vision and @cite van1995estimators. Good physical explanation of a gradient structure tensor is given in @cite yang1996structure. Also, you can refer to a wikipedia page [Structure tensor]. |
||||
@note A anisotropic image on this page is a real world image. |
||||
|
||||
### What is the gradient structure tensor? |
||||
|
||||
In mathematics, the gradient structure tensor (also referred to as the second-moment matrix, the second order moment tensor, the inertia tensor, etc.) is a matrix derived from the gradient of a function. It summarizes the predominant directions of the gradient in a specified neighborhood of a point, and the degree to which those directions are coherent (coherency). The gradient structure tensor is widely used in image processing and computer vision for 2D/3D image segmentation, motion detection, adaptive filtration, local image features detection, etc. |
||||
|
||||
Important features of anisotropic images include orientation and coherency of a local anisotropy. In this paper we will show how to estimate orientation and coherency, and how to segment an anisotropic image with a single local orientation by a gradient structure tensor. |
||||
|
||||
The gradient structure tensor of an image is a 2x2 symmetric matrix. Eigenvectors of the gradient structure tensor indicate local orientation, whereas eigenvalues give coherency (a measure of anisotropism). |
||||
|
||||
The gradient structure tensor \f$J\f$ of an image \f$Z\f$ can be written as: |
||||
|
||||
\f[J = \begin{bmatrix} |
||||
J_{11} & J_{12} \\ |
||||
J_{12} & J_{22} |
||||
\end{bmatrix}\f] |
||||
|
||||
where \f$J_{11} = M[Z_{x}^{2}]\f$, \f$J_{22} = M[Z_{y}^{2}]\f$, \f$J_{12} = M[Z_{x}Z_{y}]\f$ - components of the tensor, \f$M[]\f$ is a symbol of mathematical expectation (we can consider this operation as averaging in a window w), \f$Z_{x}\f$ and \f$Z_{y}\f$ are partial derivatives of an image \f$Z\f$ with respect to \f$x\f$ and \f$y\f$. |
||||
|
||||
The eigenvalues of the tensor can be found in the below formula: |
||||
\f[\lambda_{1,2} = J_{11} + J_{22} \pm \sqrt{(J_{11} - J_{22})^{2} + 4J_{12}^{2}}\f] |
||||
where \f$\lambda_1\f$ - largest eigenvalue, \f$\lambda_2\f$ - smallest eigenvalue. |
||||
|
||||
### How to estimate orientation and coherency of an anisotropic image by gradient structure tensor? |
||||
|
||||
The orientation of an anisotropic image: |
||||
\f[\alpha = 0.5arctg\frac{2J_{12}}{J_{22} - J_{11}}\f] |
||||
|
||||
Coherency: |
||||
\f[C = \frac{\lambda_1 - \lambda_2}{\lambda_1 + \lambda_2}\f] |
||||
|
||||
The coherency ranges from 0 to 1. For ideal local orientation (\f$\lambda_2\f$ = 0, \f$\lambda_1\f$ > 0) it is one, for an isotropic gray value structure (\f$\lambda_1\f$ = \f$\lambda_2\f$ > 0) it is zero. |
||||
|
||||
Source code |
||||
----------- |
||||
|
||||
You can find source code in the `samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp` of the OpenCV source code library. |
||||
|
||||
@include cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp |
||||
|
||||
Explanation |
||||
----------- |
||||
An anisotropic image segmentation algorithm consists of a gradient structure tensor calculation, an orientation calculation, a coherency calculation and an orientation and coherency thresholding: |
||||
@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp main |
||||
|
||||
A function calcGST() calculates orientation and coherency by using a gradient structure tensor. An input parameter w defines a window size: |
||||
@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp calcGST |
||||
|
||||
The below code applies a thresholds LowThr and HighThr to image orientation and a threshold C_Thr to image coherency calculated by the previous function. LowThr and HighThr define orientation range: |
||||
@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp thresholding |
||||
|
||||
And finally we combine thresholding results: |
||||
@snippet samples/cpp/tutorial_code/ImgProc/anisotropic_image_segmentation/anisotropic_image_segmentation.cpp combining |
||||
|
||||
Result |
||||
------ |
||||
|
||||
Below you can see the real anisotropic image with single direction: |
||||
 |
||||
|
||||
Below you can see the orientation and coherency of the anisotropic image: |
||||
 |
||||
 |
||||
|
||||
Below you can see the segmentation result: |
||||
 |
||||
|
||||
The result has been computed with w = 52, C_Thr = 0.43, LowThr = 35, HighThr = 57. We can see that the algorithm selected only the areas with one single direction. |
||||
|
||||
References |
||||
------ |
||||
- [Structure tensor] - structure tensor description on the wikipedia |
||||
|
||||
<!-- invisible references list --> |
||||
[Structure tensor]: https://en.wikipedia.org/wiki/Structure_tensor |
||||
|
After Width: | Height: | Size: 20 KiB |
|
After Width: | Height: | Size: 40 KiB |
|
After Width: | Height: | Size: 19 KiB |
|
After Width: | Height: | Size: 32 KiB |
@ -0,0 +1,182 @@ |
||||
#!/usr/bin/env python |
||||
import os |
||||
import cv2 as cv |
||||
import numpy as np |
||||
|
||||
from tests_common import NewOpenCVTests, unittest |
||||
|
||||
def normAssert(test, a, b, lInf=1e-5): |
||||
test.assertLess(np.max(np.abs(a - b)), lInf) |
||||
|
||||
def inter_area(box1, box2): |
||||
x_min, x_max = max(box1[0], box2[0]), min(box1[2], box2[2]) |
||||
y_min, y_max = max(box1[1], box2[1]), min(box1[3], box2[3]) |
||||
return (x_max - x_min) * (y_max - y_min) |
||||
|
||||
def area(box): |
||||
return (box[2] - box[0]) * (box[3] - box[1]) |
||||
|
||||
def box2str(box): |
||||
left, top = box[0], box[1] |
||||
width, height = box[2] - left, box[3] - top |
||||
return '[%f x %f from (%f, %f)]' % (width, height, left, top) |
||||
|
||||
def normAssertDetections(test, ref, out, confThreshold=0.0, scores_diff=1e-5, boxes_iou_diff=1e-4): |
||||
ref = np.array(ref, np.float32) |
||||
refClassIds, testClassIds = ref[:, 1], out[:, 1] |
||||
refScores, testScores = ref[:, 2], out[:, 2] |
||||
refBoxes, testBoxes = ref[:, 3:], out[:, 3:] |
||||
|
||||
matchedRefBoxes = [False] * len(refBoxes) |
||||
errMsg = '' |
||||
for i in range(len(refBoxes)): |
||||
testScore = testScores[i] |
||||
if testScore < confThreshold: |
||||
continue |
||||
|
||||
testClassId, testBox = testClassIds[i], testBoxes[i] |
||||
matched = False |
||||
for j in range(len(refBoxes)): |
||||
if (not matchedRefBoxes[j]) and testClassId == refClassIds[j] and \ |
||||
abs(testScore - refScores[j]) < scores_diff: |
||||
interArea = inter_area(testBox, refBoxes[j]) |
||||
iou = interArea / (area(testBox) + area(refBoxes[j]) - interArea) |
||||
if abs(iou - 1.0) < boxes_iou_diff: |
||||
matched = True |
||||
matchedRefBoxes[j] = True |
||||
if not matched: |
||||
errMsg += '\nUnmatched prediction: class %d score %f box %s' % (testClassId, testScore, box2str(testBox)) |
||||
|
||||
for i in range(len(refBoxes)): |
||||
if (not matchedRefBoxes[i]) and refScores[i] > confThreshold: |
||||
errMsg += '\nUnmatched reference: class %d score %f box %s' % (refClassIds[i], refScores[i], box2str(refBoxes[i])) |
||||
if errMsg: |
||||
test.fail(errMsg) |
||||
|
||||
|
||||
# Returns a simple one-layer network created from Caffe's format |
||||
def getSimpleNet(): |
||||
prototxt = """ |
||||
name: "simpleNet" |
||||
input: "data" |
||||
layer { |
||||
type: "Identity" |
||||
name: "testLayer" |
||||
top: "testLayer" |
||||
bottom: "data" |
||||
} |
||||
""" |
||||
return cv.dnn.readNetFromCaffe(bytearray(prototxt, 'utf8')) |
||||
|
||||
|
||||
def testBackendAndTarget(backend, target): |
||||
net = getSimpleNet() |
||||
net.setPreferableBackend(backend) |
||||
net.setPreferableTarget(target) |
||||
inp = np.random.standard_normal([1, 2, 3, 4]).astype(np.float32) |
||||
try: |
||||
net.setInput(inp) |
||||
net.forward() |
||||
except BaseException as e: |
||||
return False |
||||
return True |
||||
|
||||
|
||||
haveInfEngine = testBackendAndTarget(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_TARGET_CPU) |
||||
dnnBackendsAndTargets = [ |
||||
[cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_TARGET_CPU], |
||||
] |
||||
|
||||
if haveInfEngine: |
||||
dnnBackendsAndTargets.append([cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_TARGET_CPU]) |
||||
if testBackendAndTarget(cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_TARGET_MYRIAD): |
||||
dnnBackendsAndTargets.append([cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_TARGET_MYRIAD]) |
||||
|
||||
if cv.ocl.haveOpenCL() and cv.ocl.useOpenCL(): |
||||
dnnBackendsAndTargets.append([cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_TARGET_OPENCL]) |
||||
dnnBackendsAndTargets.append([cv.dnn.DNN_BACKEND_OPENCV, cv.dnn.DNN_TARGET_OPENCL_FP16]) |
||||
if haveInfEngine: # FIXIT Check Intel iGPU only |
||||
dnnBackendsAndTargets.append([cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_TARGET_OPENCL]) |
||||
dnnBackendsAndTargets.append([cv.dnn.DNN_BACKEND_INFERENCE_ENGINE, cv.dnn.DNN_TARGET_OPENCL_FP16]) |
||||
|
||||
|
||||
def printParams(backend, target): |
||||
backendNames = { |
||||
cv.dnn.DNN_BACKEND_OPENCV: 'OCV', |
||||
cv.dnn.DNN_BACKEND_INFERENCE_ENGINE: 'DLIE' |
||||
} |
||||
targetNames = { |
||||
cv.dnn.DNN_TARGET_CPU: 'CPU', |
||||
cv.dnn.DNN_TARGET_OPENCL: 'OCL', |
||||
cv.dnn.DNN_TARGET_OPENCL_FP16: 'OCL_FP16', |
||||
cv.dnn.DNN_TARGET_MYRIAD: 'MYRIAD' |
||||
} |
||||
print('%s/%s' % (backendNames[backend], targetNames[target])) |
||||
|
||||
|
||||
class dnn_test(NewOpenCVTests): |
||||
|
||||
def find_dnn_file(self, filename, required=True): |
||||
return self.find_file(filename, [os.environ.get('OPENCV_DNN_TEST_DATA_PATH', os.getcwd())], required=required) |
||||
|
||||
def test_blobFromImage(self): |
||||
np.random.seed(324) |
||||
|
||||
width = 6 |
||||
height = 7 |
||||
scale = 1.0/127.5 |
||||
mean = (10, 20, 30) |
||||
|
||||
# Test arguments names. |
||||
img = np.random.randint(0, 255, [4, 5, 3]).astype(np.uint8) |
||||
blob = cv.dnn.blobFromImage(img, scale, (width, height), mean, True, False) |
||||
blob_args = cv.dnn.blobFromImage(img, scalefactor=scale, size=(width, height), |
||||
mean=mean, swapRB=True, crop=False) |
||||
normAssert(self, blob, blob_args) |
||||
|
||||
# Test values. |
||||
target = cv.resize(img, (width, height), interpolation=cv.INTER_LINEAR) |
||||
target = target.astype(np.float32) |
||||
target = target[:,:,[2, 1, 0]] # BGR2RGB |
||||
target[:,:,0] -= mean[0] |
||||
target[:,:,1] -= mean[1] |
||||
target[:,:,2] -= mean[2] |
||||
target *= scale |
||||
target = target.transpose(2, 0, 1).reshape(1, 3, height, width) # to NCHW |
||||
normAssert(self, blob, target) |
||||
|
||||
|
||||
def test_face_detection(self): |
||||
testdata_required = bool(os.environ.get('OPENCV_DNN_TEST_REQUIRE_TESTDATA', False)) |
||||
proto = self.find_dnn_file('dnn/opencv_face_detector.prototxt2', required=testdata_required) |
||||
model = self.find_dnn_file('dnn/opencv_face_detector.caffemodel', required=testdata_required) |
||||
if proto is None or model is None: |
||||
raise unittest.SkipTest("Missing DNN test files (dnn/opencv_face_detector.{prototxt/caffemodel}). Verify OPENCV_DNN_TEST_DATA_PATH configuration parameter.") |
||||
|
||||
img = self.get_sample('gpu/lbpcascade/er.png') |
||||
blob = cv.dnn.blobFromImage(img, mean=(104, 177, 123), swapRB=False, crop=False) |
||||
|
||||
ref = [[0, 1, 0.99520785, 0.80997437, 0.16379407, 0.87996572, 0.26685631], |
||||
[0, 1, 0.9934696, 0.2831718, 0.50738752, 0.345781, 0.5985168], |
||||
[0, 1, 0.99096733, 0.13629119, 0.24892329, 0.19756334, 0.3310290], |
||||
[0, 1, 0.98977017, 0.23901358, 0.09084064, 0.29902688, 0.1769477], |
||||
[0, 1, 0.97203469, 0.67965847, 0.06876482, 0.73999709, 0.1513494], |
||||
[0, 1, 0.95097077, 0.51901293, 0.45863652, 0.5777427, 0.5347801]] |
||||
|
||||
print('\n') |
||||
for backend, target in dnnBackendsAndTargets: |
||||
printParams(backend, target) |
||||
|
||||
net = cv.dnn.readNet(proto, model) |
||||
net.setPreferableBackend(backend) |
||||
net.setPreferableTarget(target) |
||||
net.setInput(blob) |
||||
out = net.forward().reshape(-1, 7) |
||||
|
||||
scoresDiff = 4e-3 if target in [cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD] else 1e-5 |
||||
iouDiff = 2e-2 if target in [cv.dnn.DNN_TARGET_OPENCL_FP16, cv.dnn.DNN_TARGET_MYRIAD] else 1e-4 |
||||
|
||||
normAssertDetections(self, ref, out, 0.5, scoresDiff, iouDiff) |
||||
|
||||
if __name__ == '__main__': |
||||
NewOpenCVTests.bootstrap() |
||||
Loading…
Reference in new issue