eigenImage.hpp

Go to the documentation of this file.

/** \file eigenImage.hpp
  * \brief Tools for using the eigen library for image processing
  * \ingroup image_processing_files
  * \author Jared R. Males (jaredmales@gmail.com)
  *
  */
 
//***********************************************************************//
// Copyright 2015, 2016, 2017 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef improc_eigenImage_hpp
#define improc_eigenImage_hpp
 
#pragma GCC system_header
#include <Eigen/Dense>
 
#include "../math/vectorUtils.hpp"
 
namespace mx
{
namespace improc 
{
   
///Definition of the eigenImage type, which is an alias for Eigen::Array.
/** \ingroup eigen_image_processing
  */
template<typename scalarT>
using eigenImage = Eigen::Array<scalarT, -1, -1>;
 
///Definition of the eigenMap type, which is an alias for Eigen::Map<Array>.
/** \ingroup eigen_image_processing
  */
template<typename scalarT>
using eigenMap = Eigen::Map<Eigen::Array<scalarT, -1, -1>>;
 
///Test whether a type is an eigenCube by testing whether it has a typedef of "is_eigenCube"
/** Used for compile-time determination of type
  * Example usage:
  * \code
  * bool is_eC = is_eigenCube<eigenCube<float> >; //Evaluates to true
  * bool is_not_eC = is_eigenCube<eigenImagef>; //Evaluates to false
  * \endcode
  * 
  * This was taken directly from the example at http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
  * 
  * \ingroup eigen_image_processing
  */
template <typename T>
struct is_eigenCube 
{
   // Types "yes" and "no" are guaranteed to have different sizes,
   // specifically sizeof(yes) == 1 and sizeof(no) == 2.
   typedef char yes[1];
   typedef char no[2];
 
   template <typename imageT>
   static yes& test(typename imageT::is_eigenCube*);
 
   template <typename>
   static no& test(...);
 
   // If the "sizeof" of the result of calling test<T>(0) would be equal to sizeof(yes),
   // the first overload worked and T has a nested type named "is_eigenCube".
   static const bool value = sizeof(test<T>(0)) == sizeof(yes);
};
 
 
///Function object to return the number of planes for any Eigen like object, whether 2D or a 3D cube.
/** Uses SFINAE to check for 3D eigenCube.
  *
  * \ingroup eigen_image_processing 
  */
template<typename arrT, bool isCube=is_eigenCube<arrT>::value>
struct eigenArrPlanes
{
   //If it's an eigenCube, call planes planes()
   int operator()(const arrT & arr)
   {
      return arr.planes(); 
   }
};
 
template<typename arrT>
struct eigenArrPlanes<arrT, false>
{
   //If it's not an eigenCube, never call planes()
   int operator()(const arrT & arr)
   {
      return 1;
   }
};
 
/// Calculate the median of an Eigen-like array.
/** Calculates the median of the entire array, allowing for some pixels to be ignored using a mask.
  * Working memory can be retained between calls.
  * 
  * \tparam imageT is an Eigen-like type
  * \tparam maskT is an Eigen-like type
  * 
  * \returns the median of the unmasked pixels of mat, using \ref vectorMedianInPlace().
  * 
  * \ingroup eigen_image_processing
  * 
  */ 
template<typename imageT, typename maskT=imageT>
typename imageT::Scalar imageMedian( const imageT & mat,                            ///< [in] the image to take the median of
                                     const maskT * mask,                            ///< [in] if non-0, a 1/0 mask where 0 pixels are ignored.
                                     std::vector<typename imageT::Scalar> * work =0 ///< [in] [optional] working memory can be retained and re-passed.  Is resized.
                                   )
{
   typename imageT::Scalar med;
   
   bool localWork = false;
   if(work == 0) 
   {
      work = new std::vector<typename imageT::Scalar>;
      localWork = true;
   }
   
   int sz = mat.size();
   
   if(mask)
   {
      sz = mask->sum();
   }
   
   work->resize(sz);
   
   int ii = 0;
   for(int i=0;i<mat.rows();++i)
   {
      for(int j=0; j<mat.cols();++j)
      {
         if(mask)
         {
            if( (*mask)(i,j) == 0) continue;
         }
         
         (*work)[ii] = mat(i,j);
         ++ii;
      }
   }
 
   
   med = math::vectorMedianInPlace(*work);
   
   if(localWork) delete work;
   
   return med;
} 
 
/// Calculate the median of an Eigen-like array.
/** Calculates the median of the entire array.
  * Working memory can be retained between calls.
  * 
  * \tparam imageT is an Eigen-like type
  * 
  * \returns the median of the unmasked pixels of mat, using \ref vectorMedianInPlace().
  * 
  * \ingroup eigen_image_processing
  * 
  */ 
template<typename imageT>
typename imageT::Scalar imageMedian( const imageT & mat,                            ///< [in] the image to take the median of
                                     std::vector<typename imageT::Scalar> * work =0 ///< [in] [optional] working memory can be retained and re-passed.
                                   )
{
   return imageMedian( mat, (Eigen::Array<typename imageT::Scalar,-1,-1> *) 0, work);
}
 
 
} //namespace improc
} //namespace mx
 
#endif //improc_eigenImage_hpp