volume_d.h

Go to the documentation of this file.

/* Copyright (C) 2000-2013 CEA
 *
 * This software and supporting documentation were developed by
 *     bioPICSEL
 *     CEA/DSV/I²BM/MIRCen/LMN, Batiment 61,
 *     18, route du Panorama
 *     92265 Fontenay-aux-Roses
 *     France
 */
 
#ifndef PRIMATOLOGIST_UTILITY_VOLUME_D_H
#define PRIMATOLOGIST_UTILITY_VOLUME_D_H
 
#include <primatologist/utility/volume.h>
#include <aims/vector/vector.h>
#include <cartodata/volume/volume.h>
 
namespace aims {
namespace vol {
 
  template <typename T>
  carto::VolumeRef<T> empty()
  {
    carto::VolumeRef<T> vol( (carto::Volume<T>*)0 );
    return vol;
  }
 
  template <typename T>
  carto::VolumeRef<T> select( const carto::VolumeRef<T> & in, int t )
  {
    return in.view( Point4di( 0, 0, 0, t ),
                    Point4di( in.getSizeX(), in.getSizeY(),
                              in.getSizeZ(), 1 ) );
  }
 
  template <typename P, typename T>
  bool inside( const P & p, const carto::VolumeRef<T> & input )
  {
    std::vector<int> size = input.getSize();
    for( int i = 0; i < p.size(); ++i )
      if( p[i] < 0 || p[i] >= size[i] )
        return false;
    return true;
  }
 
  template <typename P, typename T>
  bool insideAllocated( const P & p, const carto::VolumeRef<T> & input )
  {
    std::vector<int> size = input.getSize();
    std::vector<int> b = input.getBorders();
    for( int i = 0; i < p.size(); ++i )
      if( p[i] < -b[i/2] || p[i] >= size[i] + b[i/2+1] )
        return false;
    return true;
  }
 
  template <typename T>
  bool inside( const Point4di & p, const carto::VolumeRef<T> & input )
  {
    return 0 <= p[0] && p[0] < input.getSizeX() &&
           0 <= p[1] && p[1] < input.getSizeY() &&
           0 <= p[2] && p[2] < input.getSizeZ() &&
           0 <= p[3] && p[3] < input.getSizeT();
  }
 
  template <typename T>
  bool insideAllocated( const Point4di & p, const carto::VolumeRef<T> & input )
  {
    std::vector<int> b = input.getBorders();
    return -b[0] <= p[0] && p[0] < input.getSizeX() + b[1] &&
           -b[2] <= p[1] && p[1] < input.getSizeY() + b[3] &&
           -b[4] <= p[2] && p[2] < input.getSizeZ() + b[5] &&
           -b[6] <= p[3] && p[3] < input.getSizeT() + b[7];
  }
 
  template <typename T, typename M>
  carto::VolumeRef<T> &
  clip( carto::VolumeRef<T> & in,
        const typename type::identity<T>::type & min,
        const typename type::identity<T>::type & max,
        const carto::VolumeRef<M> & mask )
  {
    for( int z = 0; z < in.getSizeZ(); ++z )
    for( int y = 0; y < in.getSizeY(); ++y )
    for( int x = 0; x < in.getSizeX(); ++x )
    if( !mask.get() || mask( x, y, z ) != 0 )
    for( int t = 0; t < in.getSizeT(); ++t )
    {
      if( in( x, y,z , t) < min )
        in( x, y, z, t ) = min;
      else if( in( x, y, z, t ) > max )
        in( x, y, z, t ) = max;
    }
    return in;
  }
 
  template <typename T>
  carto::VolumeRef<T> &
  clip( carto::VolumeRef<T> & in,
        const typename type::identity<T>::type & min,
        const typename type::identity<T>::type & max )
  {
    return clip( in, min, max, vol::empty<int>() );
  }
 
  template <typename T, typename M>
  carto::VolumeRef<T>
  newClip( carto::VolumeRef<T> & in,
           const typename type::identity<T>::type & min,
           const typename type::identity<T>::type & max,
           const carto::VolumeRef<M> & mask )
  {
    carto::VolumeRef<T> copy = in.copy();
    clip( copy, min, max, mask );
    return copy;
  }
 
  template <typename T>
  carto::VolumeRef<T>
  newClip( carto::VolumeRef<T> & in,
           const typename type::identity<T>::type & min,
           const typename type::identity<T>::type & max )
  {
    carto::VolumeRef<T> copy = in.copy();
    clip( copy, min, max );
    return copy;
  }
 
  template <typename T1, typename T2, typename M>
  uintmax_t
  sumLogicalDiff( const carto::VolumeRef<T1> & one,
                  const carto::VolumeRef<T2> & two,
                  const carto::VolumeRef<M>  & mask )
  {
    if( one.getSizeX() != two.getSizeX() ||
        one.getSizeY() != two.getSizeY() ||
        one.getSizeZ() != two.getSizeZ() ||
        one.getSizeT() != two.getSizeT() )
      throw std::invalid_argument( "aims::vol::sumLogicalDiff: volumes "
                                   "should have similar dimensions" );
 
    uintmax_t sum = 0;
    for( int z = 0; z < one.getSizeZ(); ++z )
    for( int y = 0; y < one.getSizeY(); ++y )
    for( int x = 0; x < one.getSizeX(); ++x )
    if( !mask.get() || mask( x, y, z ) != 0 )
    for( int t = 0; t < one.getSizeT(); ++t )
      if( one( x, y, z, t ) != two( x, y, z, t ) )
        ++sum;
    return sum;
  }
 
  template <typename T1, typename T2>
  uintmax_t
  sumLogicalDiff( const carto::VolumeRef<T1> & one,
                  const carto::VolumeRef<T2> & two )
  {
    return sumLogicalDiff( one, two, empty<int>() );
  }
 
  template <typename T, typename M>
  typename carto::DataTypeTraits<T>::LongType
  sum( const carto::VolumeRef<T> & in,
       const carto::VolumeRef<M>  & mask )
  {
    typename carto::DataTypeTraits<T>::LongType aggregate = 0;
    for( int z = 0; z < in.getSizeZ(); ++z )
    for( int y = 0; y < in.getSizeY(); ++y )
    for( int x = 0; x < in.getSizeX(); ++x )
    if( !mask.get() || mask( x, y, z ) != 0 )
    for( int t = 0; t < in.getSizeT(); ++t )
    {
      aggregate += in( x, y, z, t );
    }
    return aggregate;
  }
 
} // namespace vol
} // namespace aims
 
#endif // PRIMATOLOGIST_UTILITY_VOLUME_D_H