Spectral Residual Saliency added

modules/saliency/include/opencv2/saliency/saliencyBaseClasses.hpp

@@ -95,7 +95,9 @@ class CV_EXPORTS_W StaticSaliency : public virtual Saliency
     Params();
   };
 
- //protected:
+  bool computeBinaryMap( const Mat& saliencyMap, Mat& outputMat );
+
+  //protected:
   //virtual bool computeSaliencyImpl( const Mat& image, Mat& saliencyMap ) = 0;
 
  private:
@@ -111,7 +113,7 @@ class CV_EXPORTS_W MotionSaliency : public virtual Saliency
     Params();
   };
 
- //protected:
+  //protected:
   //virtual bool computeSaliencyImpl( const Mat& image, Mat& saliencyMap ) = 0;
 
  private:
@@ -128,7 +130,7 @@ class CV_EXPORTS_W Objectness : public virtual Saliency
   };
 
 // protected:
- // virtual bool computeSaliencyImpl( const Mat& image, Mat& saliencyMap ) = 0;
+  // virtual bool computeSaliencyImpl( const Mat& image, Mat& saliencyMap ) = 0;
 
  private:
   Params params;

modules/saliency/include/opencv2/saliency/saliencySpecializedClasses.hpp

@@ -65,6 +65,7 @@ class CV_EXPORTS_W StaticSaliencySpectralResidual : public StaticSaliency
   struct CV_EXPORTS Params
   {
     Params();
+    Size resizedImageSize;
     void read( const FileNode& fn );
     void write( FileStorage& fs ) const;
   };
@@ -75,7 +76,7 @@ class CV_EXPORTS_W StaticSaliencySpectralResidual : public StaticSaliency
   void write( FileStorage& fs ) const;
 
  protected:
-  bool computeKmeans( Mat& saliencyMap, Mat& outputMat );
+
   bool computeSaliencyImpl( const Mat& src, Mat& dst );
   AlgorithmInfo* info() const;
 

modules/saliency/src/staticSaliency.cpp

@@ -0,0 +1,102 @@
+/*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) 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*/
+
+#include "precomp.hpp"
+
+namespace cv
+{
+
+/**
+ * StaticSaliency
+ */
+
+/**
+ * Parameters
+ */
+
+StaticSaliency::Params::Params()
+{
+
+}
+
+bool StaticSaliency::computeBinaryMap( const Mat& saliencyMap, Mat& BinaryMap )
+{
+
+  Mat labels = Mat::zeros( saliencyMap.rows * saliencyMap.cols, 1, 1 );
+  Mat samples = Mat_<float>( saliencyMap.rows * saliencyMap.cols, 1 );
+  Mat centers;
+  TermCriteria terminationCriteria;
+  terminationCriteria.epsilon = 0.2;
+  terminationCriteria.maxCount = 1000;
+  terminationCriteria.type = TermCriteria::COUNT + TermCriteria::EPS;
+
+  int elemCounter = 0;
+  for ( int i = 0; i < saliencyMap.rows; i++ )
+  {
+    for ( int j = 0; j < saliencyMap.cols; j++ )
+    {
+      samples.at<float>( elemCounter, 0 ) = saliencyMap.at<float>( i, j );
+      elemCounter++;
+    }
+  }
+
+  kmeans( samples, 5, labels, terminationCriteria, 5, KMEANS_RANDOM_CENTERS, centers );
+
+  Mat outputMat = Mat_<float>( saliencyMap.size() );
+  int intCounter = 0;
+  for ( int x = 0; x < saliencyMap.rows; x++ )
+  {
+    for ( int y = 0; y < saliencyMap.cols; y++ )
+    {
+      outputMat.at<float>( x, y ) = centers.at<float>( labels.at<int>( intCounter, 0 ), 0 );
+      intCounter++;
+    }
+
+  }
+
+  // adaptative thresholding using Otsu's method, to make saliency map binary
+  threshold( outputMat, BinaryMap, 0, 255, THRESH_BINARY | THRESH_OTSU );
+
+  return true;
+
+}
+
+}/* namespace cv */

modules/saliency/src/staticSaliencySpectralResidual.cpp

@@ -54,7 +54,7 @@ namespace cv
 
 StaticSaliencySpectralResidual::Params::Params()
 {
-
+  resizedImageSize=Size(64,64);
 }
 
 StaticSaliencySpectralResidual::StaticSaliencySpectralResidual( const StaticSaliencySpectralResidual::Params &parameters ) :
@@ -78,69 +78,30 @@ void StaticSaliencySpectralResidual::write( cv::FileStorage& fs ) const
   params.write( fs );
 }
 
-bool StaticSaliencySpectralResidual::computeKmeans( Mat& saliencyMap, Mat& outputMat )
-{
-
-  Mat labels = Mat::zeros( saliencyMap.rows * saliencyMap.cols, 1, 1 );
-  Mat samples = Mat_<float>( saliencyMap.rows * saliencyMap.cols, 1 );
-  Mat centers;
-  TermCriteria terminationCriteria;
-  terminationCriteria.epsilon = 0.2;
-  terminationCriteria.maxCount = 1000;
-  terminationCriteria.type = TermCriteria::COUNT + TermCriteria::EPS;
-
-  int elemCounter = 0;
-  for ( int i = 0; i < saliencyMap.rows; i++ )
-  {
-    for ( int j = 0; j < saliencyMap.cols; j++ )
-    {
-      samples.at<float>( elemCounter, 0 ) = saliencyMap.at<float>( i, j );
-      elemCounter++;
-    }
-  }
-
-  kmeans( samples, 5, labels, terminationCriteria, 5, KMEANS_RANDOM_CENTERS, centers );
-
-  outputMat = Mat_<float>( saliencyMap.size() );
-  int intCounter = 0;
-  for ( int x = 0; x < saliencyMap.rows; x++ )
-  {
-    for ( int y = 0; y < saliencyMap.cols; y++ )
-    {
-      outputMat.at<float>( x, y ) = centers.at<float>( labels.at<int>( intCounter, 0 ), 0 );
-      intCounter++;
-    }
-
-  }
-
-  return true;
-
-}
 
 bool StaticSaliencySpectralResidual::computeSaliencyImpl( const Mat& image, Mat& saliencyMap )
 {
 
   Mat grayTemp, grayDown;
   std::vector<Mat> mv;
-  Size imageSize( 64, 64 );
-  Mat realImage( imageSize, CV_64F );
-  Mat imaginaryImage( imageSize, CV_64F );
+  Mat realImage( params.resizedImageSize, CV_64F );
+  Mat imaginaryImage( params.resizedImageSize, CV_64F );
   imaginaryImage.setTo( 0 );
-  Mat combinedImage( imageSize, CV_64FC2 );
+  Mat combinedImage( params.resizedImageSize, CV_64FC2 );
   Mat imageDFT;
   Mat logAmplitude;
-  Mat angle( imageSize, CV_64F );
-  Mat magnitude( imageSize, CV_64F );
+  Mat angle( params.resizedImageSize, CV_64F );
+  Mat magnitude( params.resizedImageSize, CV_64F );
   Mat logAmplitude_blur, imageGR;
 
   if( image.channels() == 3 )
   {
     cvtColor( image, imageGR, COLOR_BGR2GRAY );
-    resize( imageGR, grayDown, imageSize, 0, 0, INTER_LINEAR );
+    resize( imageGR, grayDown, params.resizedImageSize, 0, 0, INTER_LINEAR );
   }
   else
   {
-    resize( image, grayDown, imageSize, 0, 0, INTER_LINEAR );
+    resize( image, grayDown, params.resizedImageSize, 0, 0, INTER_LINEAR );
   }
 
   grayDown.convertTo( realImage, CV_64F );
@@ -176,17 +137,15 @@ bool StaticSaliencySpectralResidual::computeSaliencyImpl( const Mat& image, Mat&
 
   resize( magnitude, saliencyMap, image.size(), 0, 0, INTER_LINEAR );
 
-  // CLUSTERING BY K-MEANS
-  Mat outputMat;
-  computeKmeans( saliencyMap, outputMat );
-
+#ifdef SALIENCY_DEBUG
+  // visualize saliency map before and after K-means
   imshow( "Saliency Map", saliencyMap );
-  imshow( "K-mean", outputMat );
+#endif
 
-// FINE CLUSTERING
-  outputMat = outputMat * 255;
+//TODO try the results and then delete
+  /*outputMat = outputMat * 255;
   outputMat.convertTo( outputMat, CV_8U );
-  saliencyMap = outputMat;
+  saliencyMap = outputMat; */
 
   return true;