mirror of https://github.com/opencv/opencv.git
Merge pull request #13055 from vpisarev:remove_old_haar
Alexander Alekhin
6 years ago
commit
3a4bc0d41e
7 changed files with 12 additions and 2863 deletions
@ -1,166 +0,0 @@ |
||||
/*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) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// 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_OBJDETECT_C_H |
||||
#define OPENCV_OBJDETECT_C_H |
||||
|
||||
#include "opencv2/core/core_c.h" |
||||
|
||||
#ifdef __cplusplus |
||||
#include <deque> |
||||
#include <vector> |
||||
|
||||
extern "C" { |
||||
#endif |
||||
|
||||
/** @addtogroup objdetect_c
|
||||
@{ |
||||
*/ |
||||
|
||||
/****************************************************************************************\
|
||||
* Haar-like Object Detection functions * |
||||
\****************************************************************************************/ |
||||
|
||||
#define CV_HAAR_MAGIC_VAL 0x42500000 |
||||
#define CV_TYPE_NAME_HAAR "opencv-haar-classifier" |
||||
|
||||
#define CV_IS_HAAR_CLASSIFIER( haar ) \ |
||||
((haar) != NULL && \
|
||||
(((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL) |
||||
|
||||
#define CV_HAAR_FEATURE_MAX 3 |
||||
#define CV_HAAR_STAGE_MAX 1000 |
||||
|
||||
typedef struct CvHaarFeature |
||||
{ |
||||
int tilted; |
||||
struct |
||||
{ |
||||
CvRect r; |
||||
float weight; |
||||
} rect[CV_HAAR_FEATURE_MAX]; |
||||
} CvHaarFeature; |
||||
|
||||
typedef struct CvHaarClassifier |
||||
{ |
||||
int count; |
||||
CvHaarFeature* haar_feature; |
||||
float* threshold; |
||||
int* left; |
||||
int* right; |
||||
float* alpha; |
||||
} CvHaarClassifier; |
||||
|
||||
typedef struct CvHaarStageClassifier |
||||
{ |
||||
int count; |
||||
float threshold; |
||||
CvHaarClassifier* classifier; |
||||
|
||||
int next; |
||||
int child; |
||||
int parent; |
||||
} CvHaarStageClassifier; |
||||
|
||||
typedef struct CvHidHaarClassifierCascade CvHidHaarClassifierCascade; |
||||
|
||||
typedef struct CvHaarClassifierCascade |
||||
{ |
||||
int flags; |
||||
int count; |
||||
CvSize orig_window_size; |
||||
CvSize real_window_size; |
||||
double scale; |
||||
CvHaarStageClassifier* stage_classifier; |
||||
CvHidHaarClassifierCascade* hid_cascade; |
||||
} CvHaarClassifierCascade; |
||||
|
||||
typedef struct CvAvgComp |
||||
{ |
||||
CvRect rect; |
||||
int neighbors; |
||||
} CvAvgComp; |
||||
|
||||
/* Loads haar classifier cascade from a directory.
|
||||
It is obsolete: convert your cascade to xml and use cvLoad instead */ |
||||
CVAPI(CvHaarClassifierCascade*) cvLoadHaarClassifierCascade( |
||||
const char* directory, CvSize orig_window_size); |
||||
|
||||
CVAPI(void) cvReleaseHaarClassifierCascade( CvHaarClassifierCascade** cascade ); |
||||
|
||||
#define CV_HAAR_DO_CANNY_PRUNING 1 |
||||
#define CV_HAAR_SCALE_IMAGE 2 |
||||
#define CV_HAAR_FIND_BIGGEST_OBJECT 4 |
||||
#define CV_HAAR_DO_ROUGH_SEARCH 8 |
||||
|
||||
CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image, |
||||
CvHaarClassifierCascade* cascade, CvMemStorage* storage, |
||||
double scale_factor CV_DEFAULT(1.1), |
||||
int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0), |
||||
CvSize min_size CV_DEFAULT(cvSize(0,0)), CvSize max_size CV_DEFAULT(cvSize(0,0))); |
||||
|
||||
/* sets images for haar classifier cascade */ |
||||
CVAPI(void) cvSetImagesForHaarClassifierCascade( CvHaarClassifierCascade* cascade, |
||||
const CvArr* sum, const CvArr* sqsum, |
||||
const CvArr* tilted_sum, double scale ); |
||||
|
||||
/* runs the cascade on the specified window */ |
||||
CVAPI(int) cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade, |
||||
CvPoint pt, int start_stage CV_DEFAULT(0)); |
||||
|
||||
/** @} objdetect_c */ |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
|
||||
CV_EXPORTS CvSeq* cvHaarDetectObjectsForROC( const CvArr* image, |
||||
CvHaarClassifierCascade* cascade, CvMemStorage* storage, |
||||
std::vector<int>& rejectLevels, std::vector<double>& levelWeightds, |
||||
double scale_factor = 1.1, |
||||
int min_neighbors = 3, int flags = 0, |
||||
CvSize min_size = cvSize(0, 0), CvSize max_size = cvSize(0, 0), |
||||
bool outputRejectLevels = false ); |
||||
|
||||
#endif |
||||
|
||||
#endif /* OPENCV_OBJDETECT_C_H */ |
||||
@ -1,369 +0,0 @@ |
||||
/*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.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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*/
|
||||
|
||||
/* Haar features calculation */ |
||||
|
||||
#include "precomp.hpp" |
||||
#include "haar.hpp" |
||||
|
||||
namespace cv_haar_avx |
||||
{ |
||||
|
||||
// AVX version icvEvalHidHaarClassifier. Process 8 CvHidHaarClassifiers per call. Check AVX support before invocation!!
|
||||
#if CV_HAAR_USE_AVX |
||||
double icvEvalHidHaarClassifierAVX(CvHidHaarClassifier* classifier, |
||||
double variance_norm_factor, size_t p_offset) |
||||
{ |
||||
int CV_DECL_ALIGNED(32) idxV[8] = { 0,0,0,0,0,0,0,0 }; |
||||
uchar flags[8] = { 0,0,0,0,0,0,0,0 }; |
||||
CvHidHaarTreeNode* nodes[8]; |
||||
double res = 0; |
||||
uchar exitConditionFlag = 0; |
||||
for (;;) |
||||
{ |
||||
float CV_DECL_ALIGNED(32) tmp[8] = { 0,0,0,0,0,0,0,0 }; |
||||
nodes[0] = (classifier + 0)->node + idxV[0]; |
||||
nodes[1] = (classifier + 1)->node + idxV[1]; |
||||
nodes[2] = (classifier + 2)->node + idxV[2]; |
||||
nodes[3] = (classifier + 3)->node + idxV[3]; |
||||
nodes[4] = (classifier + 4)->node + idxV[4]; |
||||
nodes[5] = (classifier + 5)->node + idxV[5]; |
||||
nodes[6] = (classifier + 6)->node + idxV[6]; |
||||
nodes[7] = (classifier + 7)->node + idxV[7]; |
||||
|
||||
__m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor)); |
||||
|
||||
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold, |
||||
nodes[6]->threshold, |
||||
nodes[5]->threshold, |
||||
nodes[4]->threshold, |
||||
nodes[3]->threshold, |
||||
nodes[2]->threshold, |
||||
nodes[1]->threshold, |
||||
nodes[0]->threshold)); |
||||
|
||||
__m256 offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[6]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[5]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[4]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[3]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[2]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[1]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[0]->feature.rect[0], p_offset)); |
||||
|
||||
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight, |
||||
nodes[6]->feature.rect[0].weight, |
||||
nodes[5]->feature.rect[0].weight, |
||||
nodes[4]->feature.rect[0].weight, |
||||
nodes[3]->feature.rect[0].weight, |
||||
nodes[2]->feature.rect[0].weight, |
||||
nodes[1]->feature.rect[0].weight, |
||||
nodes[0]->feature.rect[0].weight); |
||||
|
||||
__m256 sum = _mm256_mul_ps(offset, weight); |
||||
|
||||
offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[6]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[5]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[4]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[3]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[2]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[1]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[0]->feature.rect[1], p_offset)); |
||||
|
||||
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight, |
||||
nodes[6]->feature.rect[1].weight, |
||||
nodes[5]->feature.rect[1].weight, |
||||
nodes[4]->feature.rect[1].weight, |
||||
nodes[3]->feature.rect[1].weight, |
||||
nodes[2]->feature.rect[1].weight, |
||||
nodes[1]->feature.rect[1].weight, |
||||
nodes[0]->feature.rect[1].weight); |
||||
|
||||
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight)); |
||||
|
||||
if (nodes[0]->feature.rect[2].p0) |
||||
tmp[0] = calc_sumf(nodes[0]->feature.rect[2], p_offset) * nodes[0]->feature.rect[2].weight; |
||||
if (nodes[1]->feature.rect[2].p0) |
||||
tmp[1] = calc_sumf(nodes[1]->feature.rect[2], p_offset) * nodes[1]->feature.rect[2].weight; |
||||
if (nodes[2]->feature.rect[2].p0) |
||||
tmp[2] = calc_sumf(nodes[2]->feature.rect[2], p_offset) * nodes[2]->feature.rect[2].weight; |
||||
if (nodes[3]->feature.rect[2].p0) |
||||
tmp[3] = calc_sumf(nodes[3]->feature.rect[2], p_offset) * nodes[3]->feature.rect[2].weight; |
||||
if (nodes[4]->feature.rect[2].p0) |
||||
tmp[4] = calc_sumf(nodes[4]->feature.rect[2], p_offset) * nodes[4]->feature.rect[2].weight; |
||||
if (nodes[5]->feature.rect[2].p0) |
||||
tmp[5] = calc_sumf(nodes[5]->feature.rect[2], p_offset) * nodes[5]->feature.rect[2].weight; |
||||
if (nodes[6]->feature.rect[2].p0) |
||||
tmp[6] = calc_sumf(nodes[6]->feature.rect[2], p_offset) * nodes[6]->feature.rect[2].weight; |
||||
if (nodes[7]->feature.rect[2].p0) |
||||
tmp[7] = calc_sumf(nodes[7]->feature.rect[2], p_offset) * nodes[7]->feature.rect[2].weight; |
||||
|
||||
sum = _mm256_add_ps(sum, _mm256_load_ps(tmp)); |
||||
|
||||
__m256 left = _mm256_set_ps(static_cast<float>(nodes[7]->left), static_cast<float>(nodes[6]->left), |
||||
static_cast<float>(nodes[5]->left), static_cast<float>(nodes[4]->left), |
||||
static_cast<float>(nodes[3]->left), static_cast<float>(nodes[2]->left), |
||||
static_cast<float>(nodes[1]->left), static_cast<float>(nodes[0]->left)); |
||||
__m256 right = _mm256_set_ps(static_cast<float>(nodes[7]->right), static_cast<float>(nodes[6]->right), |
||||
static_cast<float>(nodes[5]->right), static_cast<float>(nodes[4]->right), |
||||
static_cast<float>(nodes[3]->right), static_cast<float>(nodes[2]->right), |
||||
static_cast<float>(nodes[1]->right), static_cast<float>(nodes[0]->right)); |
||||
|
||||
_mm256_store_si256((__m256i*)idxV, _mm256_cvttps_epi32(_mm256_blendv_ps(right, left, _mm256_cmp_ps(sum, t, _CMP_LT_OQ)))); |
||||
|
||||
for (int i = 0; i < 8; i++) |
||||
{ |
||||
if (idxV[i] <= 0) |
||||
{ |
||||
if (!flags[i]) |
||||
{ |
||||
exitConditionFlag++; |
||||
flags[i] = 1; |
||||
res += (classifier + i)->alpha[-idxV[i]]; |
||||
} |
||||
idxV[i] = 0; |
||||
} |
||||
} |
||||
if (exitConditionFlag == 8) |
||||
return res; |
||||
} |
||||
} |
||||
|
||||
double icvEvalHidHaarStumpClassifierAVX(CvHidHaarClassifier* classifier, |
||||
double variance_norm_factor, size_t p_offset) |
||||
{ |
||||
float CV_DECL_ALIGNED(32) tmp[8] = { 0,0,0,0,0,0,0,0 }; |
||||
CvHidHaarTreeNode* nodes[8]; |
||||
|
||||
nodes[0] = classifier[0].node; |
||||
nodes[1] = classifier[1].node; |
||||
nodes[2] = classifier[2].node; |
||||
nodes[3] = classifier[3].node; |
||||
nodes[4] = classifier[4].node; |
||||
nodes[5] = classifier[5].node; |
||||
nodes[6] = classifier[6].node; |
||||
nodes[7] = classifier[7].node; |
||||
|
||||
__m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor)); |
||||
|
||||
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold, |
||||
nodes[6]->threshold, |
||||
nodes[5]->threshold, |
||||
nodes[4]->threshold, |
||||
nodes[3]->threshold, |
||||
nodes[2]->threshold, |
||||
nodes[1]->threshold, |
||||
nodes[0]->threshold)); |
||||
|
||||
__m256 offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[6]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[5]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[4]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[3]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[2]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[1]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[0]->feature.rect[0], p_offset)); |
||||
|
||||
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight, |
||||
nodes[6]->feature.rect[0].weight, |
||||
nodes[5]->feature.rect[0].weight, |
||||
nodes[4]->feature.rect[0].weight, |
||||
nodes[3]->feature.rect[0].weight, |
||||
nodes[2]->feature.rect[0].weight, |
||||
nodes[1]->feature.rect[0].weight, |
||||
nodes[0]->feature.rect[0].weight); |
||||
|
||||
__m256 sum = _mm256_mul_ps(offset, weight); |
||||
|
||||
offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[6]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[5]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[4]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[3]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[2]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[1]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[0]->feature.rect[1], p_offset)); |
||||
|
||||
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight, |
||||
nodes[6]->feature.rect[1].weight, |
||||
nodes[5]->feature.rect[1].weight, |
||||
nodes[4]->feature.rect[1].weight, |
||||
nodes[3]->feature.rect[1].weight, |
||||
nodes[2]->feature.rect[1].weight, |
||||
nodes[1]->feature.rect[1].weight, |
||||
nodes[0]->feature.rect[1].weight); |
||||
|
||||
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight)); |
||||
|
||||
if (nodes[0]->feature.rect[2].p0) |
||||
tmp[0] = calc_sumf(nodes[0]->feature.rect[2], p_offset) * nodes[0]->feature.rect[2].weight; |
||||
if (nodes[1]->feature.rect[2].p0) |
||||
tmp[1] = calc_sumf(nodes[1]->feature.rect[2], p_offset) * nodes[1]->feature.rect[2].weight; |
||||
if (nodes[2]->feature.rect[2].p0) |
||||
tmp[2] = calc_sumf(nodes[2]->feature.rect[2], p_offset) * nodes[2]->feature.rect[2].weight; |
||||
if (nodes[3]->feature.rect[2].p0) |
||||
tmp[3] = calc_sumf(nodes[3]->feature.rect[2], p_offset) * nodes[3]->feature.rect[2].weight; |
||||
if (nodes[4]->feature.rect[2].p0) |
||||
tmp[4] = calc_sumf(nodes[4]->feature.rect[2], p_offset) * nodes[4]->feature.rect[2].weight; |
||||
if (nodes[5]->feature.rect[2].p0) |
||||
tmp[5] = calc_sumf(nodes[5]->feature.rect[2], p_offset) * nodes[5]->feature.rect[2].weight; |
||||
if (nodes[6]->feature.rect[2].p0) |
||||
tmp[6] = calc_sumf(nodes[6]->feature.rect[2], p_offset) * nodes[6]->feature.rect[2].weight; |
||||
if (nodes[7]->feature.rect[2].p0) |
||||
tmp[7] = calc_sumf(nodes[7]->feature.rect[2], p_offset) * nodes[7]->feature.rect[2].weight; |
||||
|
||||
sum = _mm256_add_ps(sum, _mm256_load_ps(tmp)); |
||||
|
||||
__m256 alpha0 = _mm256_set_ps(classifier[7].alpha[0], |
||||
classifier[6].alpha[0], |
||||
classifier[5].alpha[0], |
||||
classifier[4].alpha[0], |
||||
classifier[3].alpha[0], |
||||
classifier[2].alpha[0], |
||||
classifier[1].alpha[0], |
||||
classifier[0].alpha[0]); |
||||
__m256 alpha1 = _mm256_set_ps(classifier[7].alpha[1], |
||||
classifier[6].alpha[1], |
||||
classifier[5].alpha[1], |
||||
classifier[4].alpha[1], |
||||
classifier[3].alpha[1], |
||||
classifier[2].alpha[1], |
||||
classifier[1].alpha[1], |
||||
classifier[0].alpha[1]); |
||||
|
||||
__m256 outBuf = _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ)); |
||||
outBuf = _mm256_hadd_ps(outBuf, outBuf); |
||||
outBuf = _mm256_hadd_ps(outBuf, outBuf); |
||||
_mm256_store_ps(tmp, outBuf); |
||||
return (tmp[0] + tmp[4]); |
||||
} |
||||
|
||||
double icvEvalHidHaarStumpClassifierTwoRectAVX(CvHidHaarClassifier* classifier, |
||||
double variance_norm_factor, size_t p_offset) |
||||
{ |
||||
float CV_DECL_ALIGNED(32) buf[8]; |
||||
CvHidHaarTreeNode* nodes[8]; |
||||
nodes[0] = classifier[0].node; |
||||
nodes[1] = classifier[1].node; |
||||
nodes[2] = classifier[2].node; |
||||
nodes[3] = classifier[3].node; |
||||
nodes[4] = classifier[4].node; |
||||
nodes[5] = classifier[5].node; |
||||
nodes[6] = classifier[6].node; |
||||
nodes[7] = classifier[7].node; |
||||
|
||||
__m256 t = _mm256_set1_ps(static_cast<float>(variance_norm_factor)); |
||||
t = _mm256_mul_ps(t, _mm256_set_ps(nodes[7]->threshold, |
||||
nodes[6]->threshold, |
||||
nodes[5]->threshold, |
||||
nodes[4]->threshold, |
||||
nodes[3]->threshold, |
||||
nodes[2]->threshold, |
||||
nodes[1]->threshold, |
||||
nodes[0]->threshold)); |
||||
|
||||
__m256 offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[6]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[5]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[4]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[3]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[2]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[1]->feature.rect[0], p_offset), |
||||
calc_sumf(nodes[0]->feature.rect[0], p_offset)); |
||||
|
||||
__m256 weight = _mm256_set_ps(nodes[7]->feature.rect[0].weight, |
||||
nodes[6]->feature.rect[0].weight, |
||||
nodes[5]->feature.rect[0].weight, |
||||
nodes[4]->feature.rect[0].weight, |
||||
nodes[3]->feature.rect[0].weight, |
||||
nodes[2]->feature.rect[0].weight, |
||||
nodes[1]->feature.rect[0].weight, |
||||
nodes[0]->feature.rect[0].weight); |
||||
|
||||
__m256 sum = _mm256_mul_ps(offset, weight); |
||||
|
||||
offset = _mm256_set_ps(calc_sumf(nodes[7]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[6]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[5]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[4]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[3]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[2]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[1]->feature.rect[1], p_offset), |
||||
calc_sumf(nodes[0]->feature.rect[1], p_offset)); |
||||
|
||||
weight = _mm256_set_ps(nodes[7]->feature.rect[1].weight, |
||||
nodes[6]->feature.rect[1].weight, |
||||
nodes[5]->feature.rect[1].weight, |
||||
nodes[4]->feature.rect[1].weight, |
||||
nodes[3]->feature.rect[1].weight, |
||||
nodes[2]->feature.rect[1].weight, |
||||
nodes[1]->feature.rect[1].weight, |
||||
nodes[0]->feature.rect[1].weight); |
||||
|
||||
sum = _mm256_add_ps(sum, _mm256_mul_ps(offset, weight)); |
||||
|
||||
__m256 alpha0 = _mm256_set_ps(classifier[7].alpha[0], |
||||
classifier[6].alpha[0], |
||||
classifier[5].alpha[0], |
||||
classifier[4].alpha[0], |
||||
classifier[3].alpha[0], |
||||
classifier[2].alpha[0], |
||||
classifier[1].alpha[0], |
||||
classifier[0].alpha[0]); |
||||
__m256 alpha1 = _mm256_set_ps(classifier[7].alpha[1], |
||||
classifier[6].alpha[1], |
||||
classifier[5].alpha[1], |
||||
classifier[4].alpha[1], |
||||
classifier[3].alpha[1], |
||||
classifier[2].alpha[1], |
||||
classifier[1].alpha[1], |
||||
classifier[0].alpha[1]); |
||||
|
||||
_mm256_store_ps(buf, _mm256_blendv_ps(alpha0, alpha1, _mm256_cmp_ps(t, sum, _CMP_LE_OQ))); |
||||
return (buf[0] + buf[1] + buf[2] + buf[3] + buf[4] + buf[5] + buf[6] + buf[7]); |
||||
} |
||||
|
||||
#endif //CV_HAAR_USE_AVX
|
||||
|
||||
} |
||||
|
||||
/* End of file. */ |
||||
File diff suppressed because it is too large
Load Diff
@ -1,101 +0,0 @@ |
||||
/*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.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, 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 Intel Corporation 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*/
|
||||
|
||||
/* Haar features calculation */ |
||||
|
||||
#ifndef OPENCV_OBJDETECT_HAAR_HPP |
||||
#define OPENCV_OBJDETECT_HAAR_HPP |
||||
|
||||
#define CV_HAAR_FEATURE_MAX_LOCAL 3 |
||||
|
||||
typedef int sumtype; |
||||
typedef double sqsumtype; |
||||
|
||||
typedef struct CvHidHaarFeature |
||||
{ |
||||
struct
|
||||
{ |
||||
sumtype *p0, *p1, *p2, *p3; |
||||
float weight; |
||||
} |
||||
rect[CV_HAAR_FEATURE_MAX_LOCAL]; |
||||
} CvHidHaarFeature; |
||||
|
||||
|
||||
typedef struct CvHidHaarTreeNode |
||||
{ |
||||
CvHidHaarFeature feature; |
||||
float threshold; |
||||
int left; |
||||
int right; |
||||
} CvHidHaarTreeNode; |
||||
|
||||
|
||||
typedef struct CvHidHaarClassifier |
||||
{ |
||||
int count; |
||||
//CvHaarFeature* orig_feature;
|
||||
CvHidHaarTreeNode* node; |
||||
float* alpha; |
||||
} CvHidHaarClassifier; |
||||
|
||||
#define calc_sumf(rect,offset) \ |
||||
static_cast<float>((rect).p0[offset] - (rect).p1[offset] - (rect).p2[offset] + (rect).p3[offset]) |
||||
|
||||
namespace cv_haar_avx |
||||
{ |
||||
#if 0 /*CV_TRY_AVX*/
|
||||
#define CV_HAAR_USE_AVX 1 |
||||
#else |
||||
#define CV_HAAR_USE_AVX 0 |
||||
#endif |
||||
|
||||
#if CV_HAAR_USE_AVX |
||||
// AVX version icvEvalHidHaarClassifier. Process 8 CvHidHaarClassifiers per call. Check AVX support before invocation!!
|
||||
double icvEvalHidHaarClassifierAVX(CvHidHaarClassifier* classifier, double variance_norm_factor, size_t p_offset); |
||||
double icvEvalHidHaarStumpClassifierAVX(CvHidHaarClassifier* classifier, double variance_norm_factor, size_t p_offset); |
||||
double icvEvalHidHaarStumpClassifierTwoRectAVX(CvHidHaarClassifier* classifier, double variance_norm_factor, size_t p_offset); |
||||
#endif |
||||
} |
||||
|
||||
#endif |
||||
|
||||
/* End of file. */ |
||||
Loading…
Reference in new issue