sitkTemplateFunctions.h

Go to the documentation of this file.

/*=========================================================================
*
*  Copyright NumFOCUS
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*         http://www.apache.org/licenses/LICENSE-2.0.txt
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
*=========================================================================*/
#ifndef sitkTemplateFunctions_h
#define sitkTemplateFunctions_h
 
#include "sitkMacro.h"
#include "sitkCommon.h"
#include "sitkExceptionObject.h"
 
#include <vector>
#include <ostream>
#include <iterator>
 
namespace itk {
 
template<unsigned int VImageDimension> class ImageRegion;
template<typename T> class Versor;
 
namespace simple {
 
template <typename T>
void SITKCommon_HIDDEN Unused( const T &) {};
 
template <typename T>
SITKCommon_HIDDEN std::ostream & operator<<( std::ostream & os, const std::vector<T>& v)
{
  if ( v.empty() )
    {
    return os << "[ ]";
    }
 
  os << "[ ";
  std::copy( v.begin(), v.end()-1, std::ostream_iterator<T>(os, ", ") );
  return os << v.back() << " ]";
}
 
template< typename TITKPointVector, typename TType>
TITKPointVector SITKCommon_HIDDEN sitkSTLVectorToITKPointVector( const std::vector< TType > & in )
{
 
  using itkPointVectorType = TITKPointVector;
  itkPointVectorType out;
 
  unsigned int Dimension = itkPointVectorType::value_type::GetPointDimension();
 
  for( unsigned int i = 0; i + Dimension <= in.size(); i += Dimension )
    {
    typename itkPointVectorType::value_type pt(&in[i]);
    out.push_back(pt);
    }
  return out;
 
}
 
template< typename TITKVector, typename TType>
TITKVector SITKCommon_HIDDEN sitkSTLVectorToITK( const std::vector< TType > & in )
{
  using itkVectorType = TITKVector;
  if ( in.size() < itkVectorType::Dimension )
    {
    sitkExceptionMacro(<<"Unable to convert vector to ITK type\n"
                      << "Expected vector of length " <<  itkVectorType::Dimension
                       << " but only got " << in.size() << " elements." );
    }
  itkVectorType out;
  for( unsigned int i = 0; i < itkVectorType::Dimension; ++i )
    {
    out[i] = in[i];
    }
  return out;
}
 
template<typename TType,  typename TITKVector>
std::vector<TType> SITKCommon_HIDDEN sitkITKVectorToSTL( const TITKVector & in )
{
  std::vector<TType> out( TITKVector::Dimension );
  for( unsigned int i = 0; i < TITKVector::Dimension; ++i )
    {
    out[i] = static_cast<TType>(in[i]);
    }
  return out;
}
 
template<typename TType,  typename TVectorOfITKVector>
std::vector<TType> SITKCommon_HIDDEN sitkVectorOfITKVectorToSTL( const TVectorOfITKVector & in )
{
  using ITKVectorType = typename TVectorOfITKVector::ValueType;
  std::vector<TType> out;
  out.reserve( in.Size()*ITKVectorType::Dimension );
  for( unsigned int i = 0; i < in.Size(); ++i )
    {
    const std::vector<TType> &temp =  sitkITKVectorToSTL<TType>(in[i]);
    out.insert(out.end(), temp.begin(), temp.end());
    }
  return out;
}
 
 
template<typename TType,  typename TITKVector>
std::vector<TType> SITKCommon_HIDDEN sitkITKVectorToSTL( const std::vector<TITKVector> & in )
{
  std::vector<TType> out;
  out.reserve( in.size()*TITKVector::Dimension );
  typename std::vector<TITKVector>::const_iterator iter = in.begin();
  while(iter!=in.end())
    {
    for( unsigned int i = 0; i < TITKVector::Dimension; ++i )
      {
      out.push_back(static_cast<TType>((*iter)[i]));
      }
    ++iter;
    }
 
  return out;
}
 
template<unsigned int VImageDimension>
std::vector<unsigned int> SITKCommon_HIDDEN sitkITKImageRegionToSTL( const ImageRegion<VImageDimension> & in )
{
  std::vector<unsigned int> out( VImageDimension*2 );
  for( unsigned int i = 0; i < VImageDimension; ++i )
    {
    out[i] = static_cast<unsigned int>(in.GetIndex(i));
    out[VImageDimension+i] = static_cast<unsigned int>(in.GetSize(i));
    }
  return out;
}
 
 
/* \brief Convert to an itk::Matrix type, where the vector is in row
 * major form. If the vector is of 0-size then an identity matrix will
 * be constructed.
 */
template< typename TDirectionType >
TDirectionType SITKCommon_HIDDEN  sitkSTLToITKDirection( const std::vector<double> &direction )
{
  TDirectionType itkDirection;
 
  if ( direction.empty() )
    {
    itkDirection.SetIdentity();
    }
  else if( direction.size() == TDirectionType::RowDimensions*TDirectionType::ColumnDimensions )
    {
    std::copy( direction.begin(), direction.end(), itkDirection.GetVnlMatrix().begin() );
    }
  else
    {
    sitkExceptionMacro(<<"Length of input ("<<direction.size()<<") does not match matrix dimensions ("
                       <<TDirectionType::RowDimensions<<", "<<TDirectionType::ColumnDimensions<<").\n");
    }
  return itkDirection;
}
 
 
template< typename TDirectionType >
std::vector<double> SITKCommon_HIDDEN  sitkITKDirectionToSTL( const TDirectionType & d)
{
  return std::vector<double>(  d.GetVnlMatrix().begin(), d.GetVnlMatrix().end() );
}
 
 
template< typename T, typename TType>
itk::Versor<T> SITKCommon_HIDDEN  sitkSTLVectorToITKVersor( const std::vector< TType > & in )
{
  using itkVectorType = itk::Versor<T>;
  if ( in.size() != 4 )
    {
    sitkExceptionMacro(<<"Unable to convert vector to ITK Versor type\n"
                      << "Expected vector of length " <<  4
                       << " but got " << in.size() << " elements." );
    }
  itkVectorType out;
  out.Set(in[0],in[1],in[2],in[3]);
  return out;
}
 
 
template< typename TType, typename T>
std::vector<TType> SITKCommon_HIDDEN  sitkITKVersorToSTL( const itk::Versor<T> & in )
{
  std::vector<TType> out(4);
  out[0] = in.GetX();
  out[1] = in.GetY();
  out[2] = in.GetZ();
  out[3] = in.GetW();
  return out;
}
 
// Based on p0052r8 : Generic Scope Guard and RAII Wrapper for the
// Standard Library
// by Peter Sommerlad and Andrew L. Sandoval
template <typename F>
struct scope_exit {
  F f_;
  bool run_;
  explicit scope_exit(F f) noexcept : f_(std::move(f)), run_(true) {}
  scope_exit(scope_exit&& rhs) noexcept : f_((rhs.run_ = false, std::move(rhs.f_))), run_(true) {}
  ~scope_exit()
  {
    if (run_)
      f_();
  }
 
  scope_exit& operator=(scope_exit&& rhs) = delete;
  scope_exit(scope_exit const&) = delete;
  scope_exit& operator=(scope_exit const&) = delete;
};
 
template <typename F>
scope_exit<F> make_scope_exit(F&& f) noexcept
{
  return scope_exit<F>{ std::forward<F>(f) };
}
 
 
}
}
 
#endif