imagePads.hpp

Go to the documentation of this file.

/** \file imagePads.hpp
  * \brief Image padding 
  * \ingroup image_processing_files
  * \author Jared R. Males (jaredmales@gmail.com)
  *
  */
 
//***********************************************************************//
// Copyright 2015, 2016, 2017, 2018 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_imagePads_hpp
#define improc_imagePads_hpp
 
#include <vector>
 
#include "../mxError.hpp"
 
namespace mx
{
namespace improc 
{
 
/** \addtogroup image_padding
  * These functions pad an image by adding rows and columns, and filling in the new pixels with appropriate values.  This can be a constant, or nearest neighbor.  A version
  * is also provided which expands an aribtrary 1/0 mask, which is useful when working with, say, circular regions of an image.
  */
 
/** \ingroup image_padding
  * @{ 
  */
 
/// Pad an image with a constant value
/** 
  * \retval 0 on success
  * \retval -1 on error
  * 
  * \tparam imOutT is an Eigen-like array
  * \tparam imInT is an Eigen-like array
  */ 
template<typename imOutT, typename imInT>
int padImage( imOutT & imOut, ///< [out] On return contains the padded image.  This will be resized.
              imInT & imIn, ///< [in] The image to be padded.
              unsigned int padSz, ///< [in] The size of the pad.  The padded image (imOut) will be 2*padSz rows and cols larger than the input.
              typename imOutT::Scalar value  ///< [in] the value to use for padding.
            )
{
   int nRows = imIn.rows() + 2*padSz;
   int nCols = imIn.cols() + 2*padSz;
   
   imOut = imOutT::Constant(nRows, nCols, value);
   
   imOut.block(padSz, padSz, imIn.rows(),imIn.cols()) = imIn;
   
   return 0;
}
 
/// Pad an image with a constant value for reference types.
/** This version can be used with Eigen reference types.
  *  
  * \retval 0 on success
  * \retval -1 on error
  * 
  * \tparam imOutT is an Eigen-like array reference
  * \tparam imInT is an Eigen-like array reference
  */ 
template<typename imOutT, typename imInT>
int padImageRef( imOutT imOut, ///< [out] On return contains the padded image.  This will be resized.
                 imInT imIn, ///< [in] The image to be padded.
                 unsigned int padSz, ///< [in] The size of the pad.  The padded image (imOut) will be 2*padSz rows and cols larger than the input.
                 typename imOutT::Scalar value ///< [in] the value to use for padding.
               )
{
   int nRows = imIn.rows() + 2*padSz;
   int nCols = imIn.cols() + 2*padSz;
 
   
   imOut = imOutT::Constant(nRows, nCols, value);
   
   imOut.block(padSz, padSz, imIn.rows(),imIn.cols()) = imIn;
   
   return 0;
}
 
/// Pad an image by repeating the values in the edge rows and columns
/** Allocates imOut to hold 2*padSz more rows and columns, and copies imIn to the center.  Then fills in the new pixels
  * by copying the edge pixels outward.
  * 
  * \retval 0 on success
  * \retval -1 on error
  * 
  * \tparam imOutT is an Eigen-like array 
  * \tparam imInT is an Eigen-like array
  */
template<typename imOutT, typename imInT>
int padImage( imOutT & imOut, ///< [out] On return contains the padded image.  This will be resized.
              imInT & imIn, ///< [in] The image to be padded.
              unsigned int padSz ///< [in] The size of the pad.  The padded image (imOut) will be 2*padSz rows and cols larger than the input.
            )
{
   int dim1 = imIn.rows();
   int dim2 = imIn.cols();
   
   imOut.resize(dim1+2*padSz, dim2 + 2*padSz);
   
   imOut.block(padSz, padSz, dim1, dim2) = imIn;
   
   //First do the left and right edge columns and corners
   for(int i = 0; i< padSz; ++i)
   {
      for(int j=0; j < imOut.cols(); ++j)
      {
         if( j < padSz )
         {
            imOut(i,j) = imIn(0, 0);
            imOut( imOut.rows()-1-i, j) = imIn( dim1-1, 0);
         }
         else if( j >= dim2 + padSz)
         {
            imOut(i,j) = imIn(0, dim2-1);
            imOut( imOut.rows()-1-i, j) = imIn( dim1-1, dim2-1);
         }
         else
         {
            imOut( i, j ) = imOut( padSz, j );
            imOut( imOut.rows() - padSz + i,  j )   = imOut( padSz + dim1-1, j );
         }
      }
   }
   
   //Now do the top and bottom rows.
   for(int i=padSz; i < dim1+padSz; ++i)
   {
      for(int j=0; j< padSz; ++j)
      {
         imOut(i,j) = imOut(i, padSz);
         imOut(i, imOut.cols()-1-j) = imOut(i, imOut.cols()-1-padSz);
      }
   }
   
   
   return 0;
}
 
/// Pad an image by repeating the values at the edge of a 1/0 mask
/** Allocates imOut to match imMask, and copies imIn to the center multiplied by the mask.  Then fills in the new pixels
  * by copying the edge pixels outward. For each pixel on the edge of the mask (touching at least one 1-valued pixel
  * in the mask), the value is chosen as the value of the nearest pixel with a 1 in the mask.  If the closest pixels are more than one equidistant pixels,
  * their mean value is used.    
  * 
  * 
  * \retval 0 on success
  * \retval -1 on error
  * 
  * \tparam imOutT is an Eigen-like array
  * \tparam imInT is an Eigen-like array 
  */
template<typename imOutT, typename imInT>
int padImage( imOutT & imOut, ///< [out] On return contains the padded image.  This will be resized.
              imInT & imIn, ///< [in] The image to be padded.
              imInT & imMask, ///< [in] The 1/0 mask image.
              unsigned int padSz ///< [in] The number of iterations of the padding loop.
            )
{
 
   typedef imInT imMaskT;
   
   int dim1 = imMask.rows();
   int dim2 = imMask.cols();
   
   imOut.resize(dim1, dim2);
   
   int stR = 0.5*(dim1 - imIn.rows());
   int stC = 0.5*(dim2 - imIn.cols());
 
 
   if(stR < 0)
   {
      mxError("padImage", MXE_INVALIDARG, "imMask must have at least as many rows as imIn.");
      return -1;
   }
   if(stC < 0)
   {
      mxError("padImage", MXE_INVALIDARG, "imMask must have at least as many columns as imIn.");
      return -1;
   }
   
   imOut.block(stR, stC, imIn.rows(), imIn.cols()) = imIn;
   
   imOut *= imMask;
   
   imMaskT tMask = imMask; //Need a modifiable mask, which grows as the image is extended
   
   std::vector<int> nmi, nmj; //Used to track which pixels of the mask need to be updated
   
   for(unsigned int n=0; n < padSz; ++n)
   {
      nmi.clear();
      nmj.clear();
      for(int ii =0; ii< dim1; ++ii)
      {
         for(int jj =0; jj<dim2; ++jj)
         {
            if(tMask(ii,jj) == 1) continue;
            
            typename imOutT::Scalar mv = 0;
            //int r, minr;// = 3;
            int nv = 0;
            
            //Loop over the neighboring pixels
            for(int i=-1; i<=1; ++i)
            {
               for(int j=-1; j<=1; ++j)
               {
                  if(i==0 && j==0) continue;
                  if( ii + i < 0 || ii + i >= dim1) continue;
                  if( jj + j < 0 || jj + j >= dim2) continue;
                  
                  if( tMask( ii+i, jj+j) == 1)
                  {
                     mv += imOut( ii+i, jj+j);
                     ++nv;
  
                  }
               }
            }
            
            //Found at least 1 neighboring pixel in the 1's part of the mask
            if(nv > 0)
            {
               imOut(ii, jj) = mv/nv;
               nmi.push_back(ii);
               nmj.push_back(jj);
            }
         }
      }
      
      for(size_t i=0; i< nmi.size(); ++i)
      {
         tMask( nmi[i], nmj[i]) = 1;
      }
      
   }
      
   return 0;
   
}
 
///Cut down a padded image
/**
  * \retval 0 on success
  * \retval -1 on error
  * 
  * \tparam imOutT is an Eigen-like array
  * \tparam imInT is an Eigen-like array
  */ 
template<typename imOutT, typename imInT>
int cutPaddedImage( imOutT & imOut,  ///< [out] On return contains the cut image.  This will be resized.
                    const imInT & imIn, ///< [in] The image to be cut down.
                    unsigned int padSz ///< [in] The size of the pad.  The output image will be smaller by 2*padSz rows and cols.
                  )
{
   if(2*padSz > imIn.rows())
   {
      mxError("cutPaddedImage", MXE_INVALIDARG, "padSz too large, must be < imIn.rows()/2");
      return -1;
   }
   
   if(2*padSz > imIn.cols())
   {
      mxError("cutPaddedImage", MXE_INVALIDARG, "padSz too large, must be < imIn.cols()/2");
      return -1;
   }
   
   int nRows = imIn.rows() - 2*padSz;
   int nCols = imIn.cols() - 2*padSz;
   
   imOut = imIn.block(padSz, padSz, nRows, nCols);
   
   return 0;
}
 
///@}
 
   
}// namespace improc 
}// namespace mx
 
#endif //improc_imagePads_hpp