diff --git a/modules/saliency/include/opencv2/saliency/kyheader.hpp b/modules/saliency/include/opencv2/saliency/kyheader.hpp new file mode 100644 index 000000000..4c8633800 --- /dev/null +++ b/modules/saliency/include/opencv2/saliency/kyheader.hpp @@ -0,0 +1,293 @@ +/*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) 2014, 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 KYHEADER_H +#define KYHEADER_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#include + +// TODO: reference additional headers your program requires here +//#include "LibLinear/linear.h" +//#include +#include "opencv2/core.hpp" + +#define CV_VERSION_ID CVAUX_STR(CV_MAJOR_VERSION) CVAUX_STR(CV_MINOR_VERSION) CVAUX_STR(CV_SUBMINOR_VERSION) +#ifdef _DEBUG +#define cvLIB(name) "opencv_" name CV_VERSION_ID "d" +#else +#define cvLIB(name) "opencv_" name CV_VERSION_ID +#endif + +//#pragma comment( lib, cvLIB("core")) +//#pragma comment( lib, cvLIB("imgproc")) +//#pragma comment( lib, cvLIB("highgui")) + +#ifdef WIN32 +/* windows stuff */ +#else +typedef unsigned long DWORD; +typedef unsigned short WORD; +typedef unsigned int UNINT32; +typedef bool BOOL; +typedef void *HANDLE; +#endif + +#ifndef _MSC_VER +typedef unsigned char BYTE; +#else +#include +#endif + +namespace cv +{ +namespace saliency +{ + +typedef std::vector vecI; +typedef const std::string CStr; +typedef const cv::Mat CMat; +typedef std::vector vecS; +typedef std::vector vecM; +typedef std::vector vecF; +typedef std::vector vecD; + +enum +{ + CV_FLIP_BOTH = -1, + CV_FLIP_VERTICAL = 0, + CV_FLIP_HORIZONTAL = 1 +}; +#define _S(str) ((str).c_str()) +#define CHK_IND(p) ((p).x >= 0 && (p).x < _w && (p).y >= 0 && (p).y < _h) +#define CV_Assert_(expr, args) \ +{\ + if(!(expr)) {\ + String msg = cv::format args; \ + printf("%s in %s:%d\n", msg.c_str(), __FILE__, __LINE__); \ + cv::error(cv::Exception(CV_StsAssert, msg, __FUNCTION__, __FILE__, __LINE__) ); }\ +} + + +// Return -1 if not in the list +template +static inline int findFromList( const T &word, const std::vector &strList ) +{ + //TODO delete test code + //cout << "\n\n" << "word" <<" "<< word << endl; + for ( int i = 0; i < strList.size(); i++ ) + { + //cout <<"test word:"<< word << " " << endl; + //cout << "Size w " << word.size() << " Size L "<< strList[i].size() << endl; + } + + std::vector::iterator it = std::find( strList.begin(), strList.end(), word ); + if( it == strList.end() ) + { + return -1; + } + else + { + int index = it - strList.begin(); + return index; + //vector::iterator index = std::distance( strList.begin(), it ); + //cout << "index" <<" "<< index << endl; + //return int( index ); + } +} +/*template + static inline int findFromList(const string &word, const vector &strList) { + //for(int i=0; i inline T sqr( T x ) +{ + return x * x; +} // out of range risk for T = byte, ... +template inline T vecSqrDist( const cv::Vec &v1, const cv::Vec &v2 ) +{ + T s = 0; + for ( int i = 0; i < D; i++ ) + s += sqr( v1[i] - v2[i] ); + return s; +} // out of range risk for T = byte, ... +template inline T vecDist( const cv::Vec &v1, const cv::Vec &v2 ) +{ + return sqrt( vecSqrDist( v1, v2 ) ); +} // out of range risk for T = byte, ... + +inline cv::Rect Vec4i2Rect( cv::Vec4i &v ) +{ + return cv::Rect( cv::Point( v[0] - 1, v[1] - 1 ), cv::Point( v[2], v[3] ) ); +} +/* +#ifdef __WIN32 +#define INT64 long long +#else +#define INT64 long +typedef unsigned long UINT64_; +//#define UINT64 unsigned long +#endif +*/ + + #if defined(_MSC_VER) + # include + # define POPCNT(x) __popcnt(x) + # define POPCNT64(x) __popcnt64(x) + #endif + + +#if defined(__GNUC__) +# define POPCNT(x) __builtin_popcount(x) +# define POPCNT64(x) __builtin_popcountll(x) +#endif + +inline int popcnt64( register uint64_t u ) +{ + u = ( u & 0x5555555555555555 ) + ( ( u >> 1 ) & 0x5555555555555555 ); + u = ( u & 0x3333333333333333 ) + ( ( u >> 2 ) & 0x3333333333333333 ); + u = ( u & 0x0f0f0f0f0f0f0f0f ) + ( ( u >> 4 ) & 0x0f0f0f0f0f0f0f0f ); + u = ( u & 0x00ff00ff00ff00ff ) + ( ( u >> 8 ) & 0x00ff00ff00ff00ff ); + u = ( u & 0x0000ffff0000ffff ) + ( ( u >> 16 ) & 0x0000ffff0000ffff ); + u = ( u & 0x00000000ffffffff ) + ( ( u >> 32 ) & 0x00000000ffffffff ); + return (int)u; +} + +inline int popcnt( register uint32_t u ) +{ + u = ( u & 0x55555555 ) + ( ( u >> 1 ) & 0x55555555 ); + u = ( u & 0x33333333 ) + ( ( u >> 2 ) & 0x33333333 ); + u = ( u & 0x0f0f0f0f ) + ( ( u >> 4 ) & 0x0f0f0f0f ); + u = ( u & 0x00ff00ff ) + ( ( u >> 8 ) & 0x00ff00ff ); + u = ( u & 0x0000ffff ) + ( ( u >> 16 ) & 0x0000ffff ); + return (int)u; +} + +inline int popcnt64_nibble( register uint64_t u ) +{ + static const uint8_t Table[] = + { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 }; + + int c = 0; + while ( u ) + { + c += Table[u & 0xf]; + u >>= 4; + } + return (int)c; +} + +inline int popcnt_nibble( register uint32_t u ) +{ + static const uint8_t Table[] = + { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 }; + + int c = 0; + while ( u ) + { + c += Table[u & 0xf]; + u >>= 4; + } + return (int)c; +} + +inline int popcnt64_byte( register uint64_t u ) +{ +#define B2(k) k, k+1, k+1, k+2 +#define B4(k) B2(k), B2(k+1), B2(k+1), B2(k+2) +#define B6(k) B4(k), B4(k+1), B4(k+1), B4(k+2) + static const uint8_t Table[] = + { B6( 0 ), B6( 1 ), B6( 1 ), B6( 2 ) }; +#undef B6 +#undef B4 +#undef B2 + + int c = 0; + while ( u ) + { + c += Table[u & 0xff]; + u >>= 8; + } + return (int)c; +} + +inline int popcnt_byte( register uint32_t u ) +{ +#define B2(k) k, k+1, k+1, k+2 +#define B4(k) B2(k), B2(k+1), B2(k+1), B2(k+2) +#define B6(k) B4(k), B4(k+1), B4(k+1), B4(k+2) + static const uint8_t Table[] = + { B6( 0 ), B6( 1 ), B6( 1 ), B6( 2 ) }; +#undef B6 +#undef B4 +#undef B2 + + int c = 0; + while ( u ) + { + c += Table[u & 0xff]; + u >>= 8; + } + return (int)c; +} + +} +} + +///// + +#endif // KYHEADER_H diff --git a/modules/saliency/include/opencv2/saliency/saliencySpecializedClasses.hpp b/modules/saliency/include/opencv2/saliency/saliencySpecializedClasses.hpp index c47a586d8..96b2f6c6f 100644 --- a/modules/saliency/include/opencv2/saliency/saliencySpecializedClasses.hpp +++ b/modules/saliency/include/opencv2/saliency/saliencySpecializedClasses.hpp @@ -42,9 +42,7 @@ #ifndef __OPENCV_SALIENCY_SPECIALIZED_CLASSES_HPP__ #define __OPENCV_SALIENCY_SPECIALIZED_CLASSES_HPP__ -#include "src/kyheader.hpp" -#include "src/ValStructVec.hpp" -#include "src/FilterTIG.hpp" +#include "opencv2/saliency/kyheader.hpp" #include #include #include @@ -179,7 +177,57 @@ class CV_EXPORTS ObjectnessBING : public Objectness AlgorithmInfo* info() const; private: - // Parameters + + class FilterTIG + { + public: + void update( CMat &w ); + + // For a W by H gradient magnitude map, find a W-7 by H-7 CV_32F matching score map + Mat matchTemplate( const cv::Mat &mag1u ); + + float dot( const int64_t tig1, const int64_t tig2, const int64_t tig4, const int64_t tig8 ); + + public: + void reconstruct( cv::Mat &w ); // For illustration purpose + + private: + static const int NUM_COMP = 2; // Number of components + static const int D = 64; // Dimension of TIG + int64_t _bTIGs[NUM_COMP]; // Binary TIG features + float _coeffs1[NUM_COMP]; // Coefficients of binary TIG features + + // For efficiently deals with different bits in CV_8U gradient map + float _coeffs2[NUM_COMP], _coeffs4[NUM_COMP], _coeffs8[NUM_COMP]; + }; + + template + struct ValStructVec + { + ValStructVec(); + int size() const; + void clear(); + void reserve( int resSz ); + void pushBack( const VT& val, const ST& structVal ); + const VT& operator ()( int i ) const; + const ST& operator []( int i ) const; + VT& operator ()( int i ); + ST& operator []( int i ); + + void sort( bool descendOrder = true ); + const std::vector &getSortedStructVal(); + std::vector > getvalIdxes(); + void append( const ValStructVec &newVals, int startV = 0 ); + + std::vector structVals; // struct values + int sz; // size of the value struct vector + std::vector > valIdxes; // Indexes after sort + bool smaller() + { + return true; + } + std::vector sortedStructVals; + }; enum { diff --git a/modules/saliency/samples/computeSaliency.cpp b/modules/saliency/samples/computeSaliency.cpp index 9148d230d..48e26fd87 100644 --- a/modules/saliency/samples/computeSaliency.cpp +++ b/modules/saliency/samples/computeSaliency.cpp @@ -46,6 +46,7 @@ using namespace std; using namespace cv; +using namespace saliency; static const char* keys = { "{@saliency_algorithm | | Saliency algorithm }" @@ -145,11 +146,7 @@ int main( int argc, char** argv ) if( saliencyAlgorithm->computeSaliency( image, saliencyMap ) ) { - /*std::cout << "-----------------OBJECTNESS-----------" << std::endl; - std::cout << "OBJECTNESS BOUNDING BOX VECTOR SIZE" << saliencyMap.size() << std::endl; - std::cout << " " << saliencyMap[0] << std::endl; - std::cout << " " << saliencyMap[1] << std::endl; - std::cout << " " << saliencyMap[2] << std::endl; */ + } } diff --git a/modules/saliency/src/BING/CmFile.hpp b/modules/saliency/src/BING/CmFile.hpp index 4ae303c6e..0be6f0dbd 100644 --- a/modules/saliency/src/BING/CmFile.hpp +++ b/modules/saliency/src/BING/CmFile.hpp @@ -49,7 +49,7 @@ #include #include #include -#include "src/kyheader.hpp" +#include "opencv2/saliency/kyheader.hpp" #endif namespace cv diff --git a/modules/saliency/src/BING/CmShow.hpp b/modules/saliency/src/BING/CmShow.hpp index 7409b7ae6..364943b15 100644 --- a/modules/saliency/src/BING/CmShow.hpp +++ b/modules/saliency/src/BING/CmShow.hpp @@ -42,7 +42,7 @@ #ifndef __OPENCV_CM_SHOW_HPP__ #define __OPENCV_CM_SHOW_HPP__ -#include "src/kyheader.hpp" +#include "opencv2/saliency/kyheader.hpp" namespace cv { diff --git a/modules/saliency/src/BING/FilterTIG.cpp b/modules/saliency/src/BING/FilterTIG.cpp index a256e9d0b..33fa92b10 100644 --- a/modules/saliency/src/BING/FilterTIG.cpp +++ b/modules/saliency/src/BING/FilterTIG.cpp @@ -41,14 +41,33 @@ #include "precomp.hpp" #include "CmShow.hpp" -#include "src/FilterTIG.hpp" namespace cv { namespace saliency { -void FilterTIG::update( CMat &w1f ) +float ObjectnessBING::FilterTIG::dot( const int64_t tig1, const int64_t tig2, const int64_t tig4, const int64_t tig8 ) +{ + int64_t bcT1 = (int64_t) POPCNT64( tig1 ); + int64_t bcT2 = (int64_t) POPCNT64( tig2 ); + int64_t bcT4 = (int64_t) POPCNT64( tig4 ); + int64_t bcT8 = (int64_t) POPCNT64( tig8 ); + + int64_t bc01 = (int64_t) ( POPCNT64(_bTIGs[0] & tig1) << 1 ) - bcT1; + int64_t bc02 = (int64_t) ( ( POPCNT64(_bTIGs[0] & tig2) << 1 ) - bcT2 ) << 1; + int64_t bc04 = (int64_t) ( ( POPCNT64(_bTIGs[0] & tig4) << 1 ) - bcT4 ) << 2; + int64_t bc08 = (int64_t) ( ( POPCNT64(_bTIGs[0] & tig8) << 1 ) - bcT8 ) << 3; + + int64_t bc11 = (int64_t) ( POPCNT64(_bTIGs[1] & tig1) << 1 ) - bcT1; + int64_t bc12 = (int64_t) ( ( POPCNT64(_bTIGs[1] & tig2) << 1 ) - bcT2 ) << 1; + int64_t bc14 = (int64_t) ( ( POPCNT64(_bTIGs[1] & tig4) << 1 ) - bcT4 ) << 2; + int64_t bc18 = (int64_t) ( ( POPCNT64(_bTIGs[1] & tig8) << 1 ) - bcT8 ) << 3; + + return _coeffs1[0] * ( bc01 + bc02 + bc04 + bc08 ) + _coeffs1[1] * ( bc11 + bc12 + bc14 + bc18 ); +} + +void ObjectnessBING::FilterTIG::update( CMat &w1f ) { CV_Assert( w1f.cols * w1f.rows == D && w1f.type() == CV_32F && w1f.isContinuous() ); float b[D], residuals[D]; @@ -72,7 +91,7 @@ void FilterTIG::update( CMat &w1f ) } } -void FilterTIG::reconstruct( Mat &w1f ) +void ObjectnessBING::FilterTIG::reconstruct( Mat &w1f ) { w1f = Mat::zeros( 8, 8, CV_32F ); float *weight = (float*) w1f.data; @@ -86,7 +105,7 @@ void FilterTIG::reconstruct( Mat &w1f ) // For a W by H gradient magnitude map, find a W-7 by H-7 CV_32F matching score map // Please refer to my paper for definition of the variables used in this function -Mat FilterTIG::matchTemplate( const Mat &mag1u ) +Mat ObjectnessBING::FilterTIG::matchTemplate( const Mat &mag1u ) { const int H = mag1u.rows, W = mag1u.cols; const Size sz( W + 1, H + 1 ); // Expand original size to avoid dealing with boundary conditions diff --git a/modules/saliency/src/BING/ValStructVec.cpp b/modules/saliency/src/BING/ValStructVec.cpp new file mode 100644 index 000000000..097c9be24 --- /dev/null +++ b/modules/saliency/src/BING/ValStructVec.cpp @@ -0,0 +1,53 @@ +/*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) 2014, 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 "precomp.hpp" + +namespace cv +{ +namespace saliency +{ + + + +} +} + diff --git a/modules/saliency/src/BING/objectnessBING.cpp b/modules/saliency/src/BING/objectnessBING.cpp index 2cc23956e..231a13fe4 100644 --- a/modules/saliency/src/BING/objectnessBING.cpp +++ b/modules/saliency/src/BING/objectnessBING.cpp @@ -501,5 +501,97 @@ bool ObjectnessBING::computeSaliencyImpl( const InputArray image, OutputArray ob return true; } +template +void ObjectnessBING::ValStructVec::append( const ValStructVec &newVals, int startV ) +{ + int newValsSize = newVals.size(); + for ( int i = 0; i < newValsSize; i++ ) + pushBack( (float) ( ( i + 300 ) * startV ), newVals[i] ); +} + +template +void ObjectnessBING::ValStructVec::sort( bool descendOrder /* = true */) +{ + if( descendOrder ) + std::sort( valIdxes.begin(), valIdxes.end(), std::greater >() ); + else + std::sort( valIdxes.begin(), valIdxes.end(), std::less >() ); +} + +template +const std::vector& ObjectnessBING::ValStructVec::getSortedStructVal() +{ + sortedStructVals.resize( sz ); + for ( int i = 0; i < sz; i++ ) + sortedStructVals[i] = structVals[valIdxes[i].second]; + return sortedStructVals; +} + +template +std::vector > ObjectnessBING::ValStructVec::getvalIdxes() +{ + return valIdxes; +} + +template +ObjectnessBING::ValStructVec::ValStructVec() +{ + clear(); +} + +template +int ObjectnessBING::ValStructVec::size() const +{ + return sz; +} + +template +void ObjectnessBING::ValStructVec::clear() +{ + sz = 0; + structVals.clear(); + valIdxes.clear(); +} + +template +void ObjectnessBING::ValStructVec::reserve( int resSz ) +{ + clear(); + structVals.reserve( resSz ); + valIdxes.reserve( resSz ); +} + +template +void ObjectnessBING::ValStructVec::pushBack( const VT& val, const ST& structVal ) +{ + valIdxes.push_back( std::make_pair( val, sz ) ); + structVals.push_back( structVal ); + sz++; +} + +template +const VT& ObjectnessBING::ValStructVec::operator ()( int i ) const +{ + return valIdxes[i].first; +} // Should be called after sort + +template +const ST& ObjectnessBING::ValStructVec::operator []( int i ) const +{ + return structVals[valIdxes[i].second]; +} // Should be called after sort + +template +VT& ObjectnessBING::ValStructVec::operator ()( int i ) +{ + return valIdxes[i].first; +} // Should be called after sort + +template +ST& ObjectnessBING::ValStructVec::operator []( int i ) +{ + return structVals[valIdxes[i].second]; +} + } /* namespace saliency */ }/* namespace cv */