1 files changed, 493 insertions, 0 deletions
diff --git a/thirdparty/linux/include/opencv2/saliency/saliencySpecializedClasses.hpp b/thirdparty/linux/include/opencv2/saliency/saliencySpecializedClasses.hpp
new file mode 100644
index 0000000..2088035
--- /dev/null
+++ b/thirdparty/linux/include/opencv2/saliency/saliencySpecializedClasses.hpp
@@ -0,0 +1,493 @@
+/*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 __OPENCV_SALIENCY_SPECIALIZED_CLASSES_HPP__
+#define __OPENCV_SALIENCY_SPECIALIZED_CLASSES_HPP__
+
+#include <cstdio>
+#include <string>
+#include <iostream>
+#include <stdint.h>
+#include "saliencyBaseClasses.hpp"
+#include "opencv2/core.hpp"
+
+namespace cv
+{
+namespace saliency
+{
+
+//! @addtogroup saliency
+//! @{
+
+/************************************ Specific Static Saliency Specialized Classes ************************************/
+
+/** @brief the Spectral Residual approach from  @cite SR
+
+Starting from the principle of natural image statistics, this method simulate the behavior of
+pre-attentive visual search. The algorithm analyze the log spectrum of each image and obtain the
+spectral residual. Then transform the spectral residual to spatial domain to obtain the saliency
+map, which suggests the positions of proto-objects.
+ */
+class CV_EXPORTS_W StaticSaliencySpectralResidual : public StaticSaliency
+{
+public:
+
+  StaticSaliencySpectralResidual();
+  virtual ~StaticSaliencySpectralResidual();
+
+  CV_WRAP static Ptr<StaticSaliencySpectralResidual> create()
+  {
+    return makePtr<StaticSaliencySpectralResidual>();
+  }
+
+  CV_WRAP bool computeSaliency( InputArray image, OutputArray saliencyMap )
+  {
+    if( image.empty() )
+      return false;
+
+    return computeSaliencyImpl( image, saliencyMap );
+  }
+
+  CV_WRAP void read( const FileNode& fn );
+  void write( FileStorage& fs ) const;
+
+  CV_WRAP int getImageWidth() const
+  {
+    return resImWidth;
+  }
+  CV_WRAP inline void setImageWidth(int val)
+  {
+    resImWidth = val;
+  }
+  CV_WRAP int getImageHeight() const
+  {
+    return resImHeight;
+  }
+  CV_WRAP void setImageHeight(int val)
+  {
+    resImHeight = val;
+  }
+
+protected:
+  bool computeSaliencyImpl( InputArray image, OutputArray saliencyMap );
+  CV_PROP_RW int resImWidth;
+  CV_PROP_RW int resImHeight;
+
+};
+
+
+/** @brief the Fine Grained Saliency approach from @cite FGS
+
+This method calculates saliency based on center-surround differences.
+High resolution saliency maps are generated in real time by using integral images.
+ */
+class CV_EXPORTS_W StaticSaliencyFineGrained : public StaticSaliency
+{
+public:
+
+  StaticSaliencyFineGrained();
+
+  CV_WRAP static Ptr<StaticSaliencyFineGrained> create()
+  {
+    return makePtr<StaticSaliencyFineGrained>();
+  }
+
+  CV_WRAP bool computeSaliency( InputArray image, OutputArray saliencyMap )
+  {
+    if( image.empty() )
+      return false;
+
+    return computeSaliencyImpl( image, saliencyMap );
+  }
+  virtual ~StaticSaliencyFineGrained();
+
+protected:
+  bool computeSaliencyImpl( InputArray image, OutputArray saliencyMap );
+
+private:
+  void calcIntensityChannel(Mat src, Mat dst);
+  void copyImage(Mat src, Mat dst);
+  void getIntensityScaled(Mat integralImage, Mat gray, Mat saliencyOn, Mat saliencyOff, int neighborhood);
+  float getMean(Mat srcArg, Point2i PixArg, int neighbourhood, int centerVal);
+  void mixScales(Mat *saliencyOn, Mat intensityOn, Mat *saliencyOff, Mat intensityOff, const int numScales);
+  void mixOnOff(Mat intensityOn, Mat intensityOff, Mat intensity);
+  void getIntensity(Mat srcArg, Mat dstArg,  Mat dstOnArg,  Mat dstOffArg, bool generateOnOff);
+};
+
+
+
+
+/************************************ Specific Motion Saliency Specialized Classes ************************************/
+
+/*!
+ * A Fast Self-tuning Background Subtraction Algorithm.
+ *
+ * This background subtraction algorithm is inspired to the work of B. Wang and P. Dudek [2]
+ * [2]  B. Wang and P. Dudek "A Fast Self-tuning Background Subtraction Algorithm", in proc of IEEE Workshop on Change Detection, 2014
+ *
+ */
+/** @brief the Fast Self-tuning Background Subtraction Algorithm from @cite BinWangApr2014
+ */
+class CV_EXPORTS_W MotionSaliencyBinWangApr2014 : public MotionSaliency
+{
+public:
+  MotionSaliencyBinWangApr2014();
+  virtual ~MotionSaliencyBinWangApr2014();
+
+  CV_WRAP static Ptr<MotionSaliencyBinWangApr2014> create()
+  {
+    return makePtr<MotionSaliencyBinWangApr2014>();
+  }
+
+  CV_WRAP bool computeSaliency( InputArray image, OutputArray saliencyMap )
+  {
+    if( image.empty() )
+      return false;
+
+    return computeSaliencyImpl( image, saliencyMap );
+  }
+
+  /** @brief This is a utility function that allows to set the correct size (taken from the input image) in the
+    corresponding variables that will be used to size the data structures of the algorithm.
+    @param W width of input image
+    @param H height of input image
+  */
+  CV_WRAP void setImagesize( int W, int H );
+  /** @brief This function allows the correct initialization of all data structures that will be used by the
+    algorithm.
+  */
+  CV_WRAP bool init();
+
+  CV_WRAP int getImageWidth() const
+  {
+    return imageWidth;
+  }
+  CV_WRAP inline void setImageWidth(int val)
+  {
+    imageWidth = val;
+  }
+  CV_WRAP int getImageHeight() const
+  {
+    return imageHeight;
+  }
+  CV_WRAP void setImageHeight(int val)
+  {
+    imageHeight = val;
+  }
+
+protected:
+  /** @brief Performs all the operations and calls all internal functions necessary for the accomplishment of the
+    Fast Self-tuning Background Subtraction Algorithm algorithm.
+    @param image input image. According to the needs of this specialized algorithm, the param image is a
+    single *Mat*.
+    @param saliencyMap Saliency Map. Is a binarized map that, in accordance with the nature of the algorithm, highlights the moving objects or areas of change in the scene.
+       The saliency map is given by a single *Mat* (one for each frame of an hypothetical video
+        stream).
+  */
+  bool computeSaliencyImpl( InputArray image, OutputArray saliencyMap );
+
+private:
+
+  // classification (and adaptation) functions
+  bool fullResolutionDetection( const Mat& image, Mat& highResBFMask );
+  bool lowResolutionDetection( const Mat& image, Mat& lowResBFMask );
+
+  // Background model maintenance functions
+  bool templateOrdering();
+  bool templateReplacement( const Mat& finalBFMask, const Mat& image );
+
+  // changing structure
+  std::vector<Ptr<Mat> > backgroundModel;// The vector represents the background template T0---TK of reference paper.
+  // Matrices are two-channel matrix. In the first layer there are the B (background value)
+  // for each pixel. In the second layer, there are the C (efficacy) value for each pixel
+  Mat potentialBackground;// Two channel Matrix. For each pixel, in the first level there are the Ba value (potential background value)
+                          // and in the secon level there are the Ca value, the counter for each potential value.
+  Mat epslonPixelsValue;  // epslon threshold
+
+  //fixed parameter
+  bool neighborhoodCheck;
+  int N_DS;// Number of template to be downsampled and used in lowResolutionDetection function
+  CV_PROP_RW int imageWidth;// Width of input image
+  CV_PROP_RW int imageHeight;//Height of input image
+  int K;// Number of background model template
+  int N;// NxN is the size of the block for downsampling in the lowlowResolutionDetection
+  float alpha;// Learning rate
+  int L0, L1;// Upper-bound values for C0 and C1 (efficacy of the first two template (matrices) of backgroundModel
+  int thetaL;// T0, T1 swap threshold
+  int thetaA;// Potential background value threshold
+  int gamma;// Parameter that controls the time that the newly updated long-term background value will remain in the
+            // long-term template, regardless of any subsequent background changes. A relatively large (eg gamma=3) will
+            //restrain the generation of ghosts.
+
+};
+
+/************************************ Specific Objectness Specialized Classes ************************************/
+
+/**
+ * \brief Objectness algorithms based on [3]
+ * [3] Cheng, Ming-Ming, et al. "BING: Binarized normed gradients for objectness estimation at 300fps." IEEE CVPR. 2014.
+ */
+
+/** @brief the Binarized normed gradients algorithm from @cite BING
+ */
+class CV_EXPORTS_W ObjectnessBING : public Objectness
+{
+public:
+
+  ObjectnessBING();
+  virtual ~ObjectnessBING();
+
+  CV_WRAP static Ptr<ObjectnessBING> create()
+  {
+    return makePtr<ObjectnessBING>();
+  }
+
+  CV_WRAP bool computeSaliency( InputArray image, OutputArray saliencyMap )
+  {
+    if( image.empty() )
+      return false;
+
+    return computeSaliencyImpl( image, saliencyMap );
+  }
+
+  CV_WRAP void read();
+  CV_WRAP void write() const;
+
+  /** @brief Return the list of the rectangles' objectness value,
+
+    in the same order as the *vector\<Vec4i\> objectnessBoundingBox* returned by the algorithm (in
+    computeSaliencyImpl function). The bigger value these scores are, it is more likely to be an
+    object window.
+     */
+  std::vector<float> getobjectnessValues();
+
+  /** @brief This is a utility function that allows to set the correct path from which the algorithm will load
+    the trained model.
+    @param trainingPath trained model path
+     */
+  CV_WRAP void setTrainingPath( const String& trainingPath );
+
+  /** @brief This is a utility function that allows to set an arbitrary path in which the algorithm will save the
+    optional results
+
+    (ie writing on file the total number and the list of rectangles returned by objectess, one for
+    each row).
+    @param resultsDir results' folder path
+     */
+  CV_WRAP void setBBResDir( const String& resultsDir );
+
+  CV_WRAP double getBase() const
+  {
+    return _base;
+  }
+  CV_WRAP inline void setBase(double val)
+  {
+    _base = val;
+  }
+  CV_WRAP int getNSS() const
+  {
+    return _NSS;
+  }
+  CV_WRAP void setNSS(int val)
+  {
+    _NSS = val;
+  }
+  CV_WRAP int getW() const
+  {
+    return _W;
+  }
+  CV_WRAP void setW(int val)
+  {
+    _W = val;
+  }
+
+protected:
+  /** @brief Performs all the operations and calls all internal functions necessary for the
+  accomplishment of the Binarized normed gradients algorithm.
+
+    @param image input image. According to the needs of this specialized algorithm, the param image is a
+    single *Mat*
+    @param objectnessBoundingBox objectness Bounding Box vector. According to the result given by this
+    specialized algorithm, the objectnessBoundingBox is a *vector\<Vec4i\>*. Each bounding box is
+    represented by a *Vec4i* for (minX, minY, maxX, maxY).
+     */
+  bool computeSaliencyImpl( InputArray image, OutputArray objectnessBoundingBox );
+
+private:
+
+  class FilterTIG
+  {
+  public:
+    void update( Mat &w );
+
+    // For a W by H gradient magnitude map, find a W-7 by H-7 CV_32F matching score map
+    Mat matchTemplate( const Mat &mag1u );
+
+    float dot( int64_t tig1, int64_t tig2, int64_t tig4, int64_t tig8 );
+    void reconstruct( 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
+  {
+    MAXBGR,
+    HSV,
+    G
+  };
+
+  double _base, _logBase;  // base for window size quantization
+  int _W;// As described in the paper: #Size, Size(_W, _H) of feature window.
+  int _NSS;// Size for non-maximal suppress
+  int _maxT, _minT, _numT;// The minimal and maximal dimensions of the template
+
+  int _Clr;//
+  static const char* _clrName[3];
+
+  // Names and paths to read model and to store results
+  std::string _modelName, _bbResDir, _trainingPath, _resultsDir;
+
+  std::vector<int> _svmSzIdxs;// Indexes of active size. It's equal to _svmFilters.size() and _svmReW1f.rows
+  Mat _svmFilter;// Filters learned at stage I, each is a _H by _W CV_32F matrix
+  FilterTIG _tigF;// TIG filter
+  Mat _svmReW1f;// Re-weight parameters learned at stage II.
+
+  // List of the rectangles' objectness value, in the same order as
+  // the  vector<Vec4i> objectnessBoundingBox returned by the algorithm (in computeSaliencyImpl function)
+  std::vector<float> objectnessValues;
+
+private:
+  // functions
+
+  inline static float LoG( float x, float y, float delta )
+  {
+    float d = - ( x * x + y * y ) / ( 2 * delta * delta );
+    return -1.0f / ( (float) ( CV_PI ) * pow( delta, 4 ) ) * ( 1 + d ) * exp( d );
+  }  // Laplacian of Gaussian
+
+  // Read matrix from binary file
+  static bool matRead( const std::string& filename, Mat& M );
+
+  void setColorSpace( int clr = MAXBGR );
+
+  // Load trained model.
+  int loadTrainedModel( std::string modelName = "" );// Return -1, 0, or 1 if partial, none, or all loaded
+
+  // Get potential bounding boxes, each of which is represented by a Vec4i for (minX, minY, maxX, maxY).
+  // The trained model should be prepared before calling this function: loadTrainedModel() or trainStageI() + trainStageII().
+  // Use numDet to control the final number of proposed bounding boxes, and number of per size (scale and aspect ratio)
+  void getObjBndBoxes( Mat &img3u, ValStructVec<float, Vec4i> &valBoxes, int numDetPerSize = 120 );
+  void getObjBndBoxesForSingleImage( Mat img, ValStructVec<float, Vec4i> &boxes, int numDetPerSize );
+
+  bool filtersLoaded()
+  {
+    int n = (int) _svmSzIdxs.size();
+    return n > 0 && _svmReW1f.size() == Size( 2, n ) && _svmFilter.size() == Size( _W, _W );
+  }
+  void predictBBoxSI( Mat &mag3u, ValStructVec<float, Vec4i> &valBoxes, std::vector<int> &sz, int NUM_WIN_PSZ = 100, bool fast = true );
+  void predictBBoxSII( ValStructVec<float, Vec4i> &valBoxes, const std::vector<int> &sz );
+
+  // Calculate the image gradient: center option as in VLFeat
+  void gradientMag( Mat &imgBGR3u, Mat &mag1u );
+
+  static void gradientRGB( Mat &bgr3u, Mat &mag1u );
+  static void gradientGray( Mat &bgr3u, Mat &mag1u );
+  static void gradientHSV( Mat &bgr3u, Mat &mag1u );
+  static void gradientXY( Mat &x1i, Mat &y1i, Mat &mag1u );
+
+  static inline int bgrMaxDist( const Vec3b &u, const Vec3b &v )
+  {
+    int b = abs( u[0] - v[0] ), g = abs( u[1] - v[1] ), r = abs( u[2] - v[2] );
+    b = max( b, g );
+    return max( b, r );
+  }
+  static inline int vecDist3b( const Vec3b &u, const Vec3b &v )
+  {
+    return abs( u[0] - v[0] ) + abs( u[1] - v[1] ) + abs( u[2] - v[2] );
+  }
+
+  //Non-maximal suppress
+  static void nonMaxSup( Mat &matchCost1f, ValStructVec<float, Point> &matchCost, int NSS = 1, int maxPoint = 50, bool fast = true );
+
+};
+
+//! @}
+
+}
+/* namespace saliency */
+} /* namespace cv */
+
+#endif