Pull Request mandatory changes 2

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 <assert.h>
+#include <string>
+#include <vector>
+#include <functional>
+#include <list>
+#include <algorithm>
+#include <iostream>
+#include <cmath>
+#include <time.h>
+#include <fstream>
+#include <stdint.h>
+//#include <omp.h>
+
+// TODO: reference additional headers your program requires here
+//#include "LibLinear/linear.h"
+//#include <opencv2/opencv.hpp>
+#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 <windows.h>
+#endif
+
+namespace cv
+{
+namespace saliency
+{
+
+typedef std::vector<int> vecI;
+typedef const std::string CStr;
+typedef const cv::Mat CMat;
+typedef std::vector<std::string> vecS;
+typedef std::vector<cv::Mat> vecM;
+typedef std::vector<float> vecF;
+typedef std::vector<double> 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<typename T>
+static inline int findFromList( const T &word, const std::vector<T> &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<cv::String>::iterator it = std::find( strList.begin(), strList.end(), word );
+  if( it == strList.end() )
+  {
+    return -1;
+  }
+  else
+  {
+    int index = it - strList.begin();
+    return index;
+    //vector<String>::iterator index = std::distance( strList.begin(), it );
+    //cout << "index" <<" "<< index << endl;
+    //return int( index );
+  }
+}
+/*template<typename T>
+ static inline int findFromList(const string &word, const vector<T> &strList) {
+ //for(int i=0; i<strList.size(); i++){
+ //cout <<"element: " <<strList[i]<<" "<<word << endl;
+ //if (std::strcmp(word.c_str(),strList[i].c_str())==0) return i;
+ }
+
+ return -1;
+ }
+ */
+
+template<typename T> inline T sqr( T x )
+{
+  return x * x;
+}  // out of range risk for T = byte, ...
+template<class T, int D> inline T vecSqrDist( const cv::Vec<T, D> &v1, const cv::Vec<T, D> &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<class T, int D> inline T vecDist( const cv::Vec<T, D> &v1, const cv::Vec<T, D> &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 <intrin.h>
+ # 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

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 "opencv2/saliency/kyheader.hpp"
-#include "src/ValStructVec.hpp"
-#include "src/FilterTIG.hpp"
 #include <cstdio>
 #include <string>
 #include <iostream>
@@ -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<typename VT, typename ST>
+  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<ST> &getSortedStructVal();
+    std::vector<std::pair<VT, int> > getvalIdxes();
+    void append( const ValStructVec<VT, ST> &newVals, int startV = 0 );
+
+    std::vector<ST> structVals;  // struct values
+    int sz;  // size of the value struct vector
+    std::vector<std::pair<VT, int> > valIdxes;  // Indexes after sort
+    bool smaller()
+    {
+      return true;
+    }
+    std::vector<ST> sortedStructVals;
+  };
 
   enum
   {

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 <saliencyAlgorithmType.[saliencyAlgorithmTypeSubType]> }"
@@ -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; */
       }
     }
 

modules/saliency/src/BING/CmFile.hpp

@@ -49,7 +49,7 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <dirent.h>
-#include "src/kyheader.hpp"
+#include "opencv2/saliency/kyheader.hpp"
 #endif
 
 namespace cv

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
 {

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

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
+{
+
+
+
+}
+}
+

modules/saliency/src/BING/objectnessBING.cpp

@@ -501,5 +501,97 @@ bool ObjectnessBING::computeSaliencyImpl( const InputArray image, OutputArray ob
   return true;
 }
 
+template<typename VT, typename ST>
+void ObjectnessBING::ValStructVec<VT, ST>::append( const ValStructVec<VT, ST> &newVals, int startV )
+{
+  int newValsSize = newVals.size();
+  for ( int i = 0; i < newValsSize; i++ )
+    pushBack( (float) ( ( i + 300 ) * startV ), newVals[i] );
+}
+
+template<typename VT, typename ST>
+void ObjectnessBING::ValStructVec<VT, ST>::sort( bool descendOrder /* = true */)
+{
+  if( descendOrder )
+    std::sort( valIdxes.begin(), valIdxes.end(), std::greater<std::pair<VT, int> >() );
+  else
+    std::sort( valIdxes.begin(), valIdxes.end(), std::less<std::pair<VT, int> >() );
+}
+
+template<typename VT, typename ST>
+const std::vector<ST>& ObjectnessBING::ValStructVec<VT, ST>::getSortedStructVal()
+{
+  sortedStructVals.resize( sz );
+  for ( int i = 0; i < sz; i++ )
+    sortedStructVals[i] = structVals[valIdxes[i].second];
+  return sortedStructVals;
+}
+
+template<typename VT, typename ST>
+std::vector<std::pair<VT, int> > ObjectnessBING::ValStructVec<VT, ST>::getvalIdxes()
+{
+  return valIdxes;
+}
+
+template<typename VT, typename ST>
+ObjectnessBING::ValStructVec<VT, ST>::ValStructVec()
+{
+  clear();
+}
+
+template<typename VT, typename ST>
+int ObjectnessBING::ValStructVec<VT, ST>::size() const
+{
+  return sz;
+}
+
+template<typename VT, typename ST>
+void ObjectnessBING::ValStructVec<VT, ST>::clear()
+{
+  sz = 0;
+  structVals.clear();
+  valIdxes.clear();
+}
+
+template<typename VT, typename ST>
+void ObjectnessBING::ValStructVec<VT, ST>::reserve( int resSz )
+{
+  clear();
+  structVals.reserve( resSz );
+  valIdxes.reserve( resSz );
+}
+
+template<typename VT, typename ST>
+void ObjectnessBING::ValStructVec<VT, ST>::pushBack( const VT& val, const ST& structVal )
+{
+  valIdxes.push_back( std::make_pair( val, sz ) );
+  structVals.push_back( structVal );
+  sz++;
+}
+
+template<typename VT, typename ST>
+const VT& ObjectnessBING::ValStructVec<VT, ST>::operator ()( int i ) const
+{
+  return valIdxes[i].first;
+}  // Should be called after sort
+
+template<typename VT, typename ST>
+const ST& ObjectnessBING::ValStructVec<VT, ST>::operator []( int i ) const
+{
+  return structVals[valIdxes[i].second];
+}  // Should be called after sort
+
+template<typename VT, typename ST>
+VT& ObjectnessBING::ValStructVec<VT, ST>::operator ()( int i )
+{
+  return valIdxes[i].first;
+}  // Should be called after sort
+
+template<typename VT, typename ST>
+ST& ObjectnessBING::ValStructVec<VT, ST>::operator []( int i )
+{
+  return structVals[valIdxes[i].second];
+}
+
 } /* namespace saliency */
 }/* namespace cv */