Image.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.9.3
// ----------------------------------------------------------------------------
// pcl/Image.h - Released 2025-02-21T12:13:32Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2025 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions 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.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS 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 PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) 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.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Image_h
#define __PCL_Image_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/AbstractImage.h>
#include <pcl/AutoLock.h>
#include <pcl/Complex.h>
#include <pcl/Compression.h>
#include <pcl/File.h>
#include <pcl/Mutex.h>
#include <pcl/PixelAllocator.h>
#include <pcl/PixelTraits.h>
#include <pcl/ReferenceArray.h>
#include <pcl/Vector.h>
 
#ifndef __PCL_IMAGE_NO_BITMAP
#  ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
#    ifndef __PI_Bitmap_h
#      include <API/Bitmap.h> // using server-side bitmaps
#    endif
using namespace pi;
#  else
#    ifndef __PCL_Bitmap_h
#      include <pcl/Bitmap.h> // using client-side bitmaps
#    endif
#  endif
#  ifndef __PCL_Color_h
#    include <pcl/Color.h>    // for RGBA
#  endif
#endif
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
namespace pi
{
   class SharedImage;
}
#endif
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
namespace ImageOp
{
   enum value_type
   {
      Nop,         // No operation
      Mov,         // a = b
      Add,         // a + b
      Sub,         // a - b
      Mul,         // a * b
      Div,         // a / b
      Pow,         // Pow( a, b )
      Dif,         // |a - b|
      Min,         // Min( a, b )
      Max,         // Max( a, b )
      Or,          // a | b
      And,         // a & b
      Xor,         // a ^ b
      Not,         // ~a
      Nor,         // ~(a | b)
      Nand,        // ~(a & b)
      Xnor,        // ~(a ^ b)
      ColorBurn,   // 1 - Min( (1 - a)/b, 1 )
      LinearBurn,  // a + b - 1
      Screen,      // 1 - (1 - a)*(1 - b)
      ColorDodge,  // Min( a/(1 - b), 1 )
      Overlay,     // (a > 0.5) ? 1 - ((1 - 2*(a - 0.5)) * (1 - b)) : 2*a*b
      SoftLight,   // (b > 0.5) ? 1 - (1 - a)*(1 - b - 0.5) : a*(b + 0.5)
      HardLight,   // (b > 0.5) ? 1 - (1 - a)*(1 - 2*(b - 0.5)) : 2*a*b
      VividLight,  // (b > 0.5) ? 1 - Max( (1 - a)/(b - 0.5)/2, 1.0 ) : Min( a/(1 - 2*b ), 1.0 )
      LinearLight, // (b > 0.5) ? Max( a + 2*(b - 0.5), 1.0 ) : Max( a + 2*b - 1, 1.0 )
      PinLight,    // (b > 0.5) ? Max( a, 2*(b - 0.5) ) : Min( a, 2*b )
      Exclusion,   // 0.5 - 2*(a - 0.5)*(b - 0.5)
      NumberOfOperators
   };
 
   inline bool IsArithmeticOperator( int op ) noexcept
   {
      return op >= Add && op <= Dif;
   }
 
   inline bool IsBitwiseLogicalOperator( int op ) noexcept
   {
      return op >= Or && op <= Xnor;
   }
 
   inline bool IsMoveOperator( int op ) noexcept
   {
      return op == Mov || op == Min || op == Max;
   }
 
   inline bool IsPixelCompositionOperator( int op ) noexcept
   {
      return op >= ColorBurn && op <= Exclusion;
   }
 
   String Id( value_type operation );
}
 
// ----------------------------------------------------------------------------
 
#define m_pixelData        m_data->data
#define m_channelData( c ) reinterpret_cast<sample*>( PCL_ASSUME_ALIGNED_32( m_pixelData[c] ) )
#define m_allocator        m_data->allocator
 
#define m_width            m_geometry->width
#define m_height           m_geometry->height
#define m_numberOfChannels m_geometry->numberOfChannels
 
#define m_colorSpace       m_color->colorSpace
#define m_RGBWS            m_color->RGBWS
 
#define m_channel          m_selected.channel
#define m_lastChannel      m_selected.lastChannel
#define m_point            m_selected.point
#define m_rectangle        m_selected.rectangle
#define m_clipLow          m_selected.clipLow
#define m_clipHigh         m_selected.clipHigh
#define m_clippedLow       m_selected.clippedLow
#define m_clippedHigh      m_selected.clippedHigh
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS ImageVariant;
class PCL_CLASS ImageTransformation;
class PCL_CLASS BidirectionalImageTransformation;
 
// ----------------------------------------------------------------------------
 
template <class P>
class PCL_CLASS GenericImage : public AbstractImage
{
public:
 
   using pixel_traits = P;
 
   using pixel_allocator = PixelAllocator<P>;
 
   using sample = typename pixel_traits::sample;
 
   using color_space = AbstractImage::color_space;
 
   using selection_stack = AbstractImage::selection_stack;
 
   using image_op = ImageOp::value_type;
 
   using sample_vector = GenericVector<sample>;
 
   using sample_array = Array<sample>;
 
   // -------------------------------------------------------------------------
 
   // -------------------------------------------------------------------------
 
   class sample_iterator
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      sample_iterator() = default;
 
      sample_iterator( image_type& image, int channel = -1 )
         : m_image( &image )
      {
         m_image->EnsureUnique();
         if ( m_image->ParseChannel( channel ) )
         {
            m_iterator = (*m_image)[channel];
            m_end = m_iterator + m_image->NumberOfPixels();
         }
      }
 
      sample_iterator( image_type& image, sample* i, sample* j )
         : m_image( &image )
         , m_iterator( i )
         , m_end( j )
      {
      }
 
      sample_iterator( const sample_iterator& ) = default;
 
      sample_iterator& operator =( const sample_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return m_image != nullptr && m_iterator != nullptr;
      }
 
      image_type& Image() const noexcept
      {
         return *m_image;
      }
 
      sample* Position() const noexcept
      {
         return m_iterator;
      }
 
      operator bool() const noexcept
      {
         return m_iterator < m_end;
      }
 
      sample& operator *() const noexcept
      {
         return *m_iterator;
      }
 
      sample_iterator& operator ++() noexcept
      {
         ++m_iterator;
         return *this;
      }
 
      sample_iterator operator ++( int ) noexcept
      {
         return sample_iterator( *m_image, m_iterator++, m_end );
      }
 
      sample_iterator& operator --() noexcept
      {
         --m_iterator;
         return *this;
      }
 
      sample_iterator operator --( int ) noexcept
      {
         return sample_iterator( *m_image, m_iterator--, m_end );
      }
 
      sample_iterator& operator +=( distance_type delta ) noexcept
      {
         m_iterator += delta;
         return *this;
      }
 
      sample_iterator& operator -=( distance_type delta ) noexcept
      {
         m_iterator -= delta;
         return *this;
      }
 
      sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         m_iterator += distance_type( dy )*m_image->Width() + distance_type( dx );
         return *this;
      }
 
      friend sample_iterator operator +( const sample_iterator& i, distance_type delta ) noexcept
      {
         return sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend sample_iterator operator +( distance_type delta, const sample_iterator& i ) noexcept
      {
         return sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend sample_iterator operator -( const sample_iterator& i, distance_type delta ) noexcept
      {
         return sample_iterator( *i.m_image, i.m_iterator - delta, i.m_end );
      }
 
      friend distance_type operator -( const sample_iterator& i, const sample_iterator& j ) noexcept
      {
         return i.m_iterator - j.m_iterator;
      }
 
      friend distance_type operator -( const sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator - j;
      }
 
      friend distance_type operator -( const sample* i, const sample_iterator& j ) noexcept
      {
         return i - j.m_iterator;
      }
 
      friend bool operator ==( const sample_iterator& i, const sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const sample_iterator& i, const sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
 
   protected:
 
            image_type*          m_image = nullptr;
            sample* __restrict__ m_iterator = nullptr;
      const sample* __restrict__ m_end = nullptr;
 
      friend class const_sample_iterator;
   };
 
   // -------------------------------------------------------------------------
 
   class const_sample_iterator
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      const_sample_iterator() = default;
 
      const_sample_iterator( const image_type& image, int channel = -1 )
         : m_image( &image )
      {
         if ( m_image->ParseChannel( channel ) )
         {
            m_iterator = (*m_image)[channel];
            m_end = m_iterator + m_image->NumberOfPixels();
         }
      }
 
      const_sample_iterator( const image_type& image, const sample* i, const sample* j )
         : m_image( &image )
         , m_iterator( i )
         , m_end( j )
      {
      }
 
      const_sample_iterator( const sample_iterator& i )
         : m_image( i.m_image )
         , m_iterator( i.m_iterator )
         , m_end( i.m_end )
      {
      }
 
      const_sample_iterator( const const_sample_iterator& ) = default;
 
      const_sample_iterator& operator =( const sample_iterator& i ) noexcept
      {
         m_image    = i.m_image;
         m_iterator = i.m_iterator;
         m_end      = i.m_end;
         return *this;
      }
 
      const_sample_iterator& operator =( const const_sample_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return m_image != nullptr && m_iterator != nullptr;
      }
 
      const image_type& Image() const noexcept
      {
         return *m_image;
      }
 
      const sample* Position() const noexcept
      {
         return m_iterator;
      }
 
      operator bool() const noexcept
      {
         return m_iterator < m_end;
      }
 
      const sample& operator *() const noexcept
      {
         return *m_iterator;
      }
 
      const_sample_iterator& operator ++() noexcept
      {
         ++m_iterator;
         return *this;
      }
 
      const_sample_iterator operator ++( int ) noexcept
      {
         return const_sample_iterator( *m_image, m_iterator++, m_end );
      }
 
      const_sample_iterator& operator --() noexcept
      {
         --m_iterator;
         return *this;
      }
 
      const_sample_iterator operator --( int ) noexcept
      {
         return const_sample_iterator( *m_image, m_iterator--, m_end );
      }
 
      const_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         m_iterator += delta;
         return *this;
      }
 
      const_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         m_iterator -= delta;
         return *this;
      }
 
      const_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         m_iterator += distance_type( dy )*m_image->Width() + distance_type( dx );
         return *this;
      }
 
      friend const_sample_iterator operator +( const const_sample_iterator& i, distance_type delta ) noexcept
      {
         return const_sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend const_sample_iterator operator +( distance_type delta, const const_sample_iterator& i ) noexcept
      {
         return const_sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend const_sample_iterator operator -( const const_sample_iterator& i, distance_type delta ) noexcept
      {
         return const_sample_iterator( *i.m_image, i.m_iterator - delta, i.m_end );
      }
 
      friend distance_type operator -( const const_sample_iterator& i, const const_sample_iterator& j ) noexcept
      {
         return i.m_iterator - j.m_iterator;
      }
 
      friend distance_type operator -( const const_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator - j;
      }
 
      friend distance_type operator -( const sample* i, const const_sample_iterator& j ) noexcept
      {
         return i - j.m_iterator;
      }
 
      friend bool operator ==( const const_sample_iterator& i, const const_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const const_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const const_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const const_sample_iterator& i, const const_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const const_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const const_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
 
   protected:
 
      const image_type*          m_image = nullptr;
      const sample* __restrict__ m_iterator = nullptr;
      const sample* __restrict__ m_end = nullptr;
   };
 
   // -------------------------------------------------------------------------
 
   template <class image_type, class sample_pointer>
   class roi_sample_iterator_base
   {
   protected:
 
      image_type*    m_image = nullptr;
      sample_pointer m_iterator = nullptr;
      sample_pointer m_rowBegin = nullptr;
      sample_pointer m_rowEnd = nullptr;
      sample_pointer m_end = nullptr;
 
      roi_sample_iterator_base() = default;
 
      roi_sample_iterator_base( image_type& image, const Rect& rect, int channel )
         : m_image( &image )
      {
         Rect r = rect;
         if ( m_image->ParseRect( r ) )
         {
            if ( m_image->ParseChannel( channel ) )
            {
               m_iterator = m_rowBegin = m_image->PixelAddress( r.x0, r.y0, channel );
               m_rowEnd = m_rowBegin + r.Width();
               m_end = m_rowEnd + ((r.Height() - 1)*m_image->Width());
            }
         }
      }
 
      roi_sample_iterator_base( image_type& image, sample_pointer i, sample_pointer j )
         : m_image( &image )
      {
         if ( j < i )
            pcl::Swap( i, j );
         m_iterator = m_rowBegin = i;
         m_rowEnd = m_rowBegin + (j - i)%m_image->Width();
         m_end = j;
      }
 
      roi_sample_iterator_base( const roi_sample_iterator_base& i ) = default;
 
      roi_sample_iterator_base& operator =( const roi_sample_iterator_base& ) = default;
 
      void Increment() noexcept
      {
         if ( ++m_iterator == m_rowEnd )
         {
            m_rowBegin += m_image->Width();
            m_rowEnd += m_image->Width();
            m_iterator = m_rowBegin;
         }
      }
 
      void Decrement() noexcept
      {
         if ( m_iterator == m_rowBegin )
         {
            m_rowBegin -= m_image->Width();
            m_rowEnd -= m_image->Width();
            m_iterator = m_rowEnd;
         }
         --m_iterator;
      }
 
      void MoveBy( int cols, int rows ) noexcept
      {
         cols += m_iterator - m_rowBegin;
         if ( cols != 0 )
         {
            int w = m_rowEnd - m_rowBegin;
            if ( pcl::Abs( cols ) >= w )
            {
               rows += cols/w;
               cols %= w;
            }
         }
         int dy = rows * m_image->Width();
         m_rowBegin += dy;
         m_rowEnd += dy;
         m_iterator = m_rowBegin + cols;
      }
   };
 
   // -------------------------------------------------------------------------
 
   class roi_sample_iterator : private roi_sample_iterator_base<GenericImage<P>, sample*>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using iterator_base = roi_sample_iterator_base<GenericImage<P>, sample*>;
 
      roi_sample_iterator() = default;
 
      roi_sample_iterator( image_type& image, const Rect& rect = Rect( 0 ), int channel = -1 )
         : iterator_base( image.EnsureUnique(), rect, channel )
      {
      }
 
      roi_sample_iterator( image_type& image, sample* i, sample* j )
         : iterator_base( image, i, j )
      {
      }
 
      roi_sample_iterator( const roi_sample_iterator& ) = default;
 
      roi_sample_iterator& operator =( const roi_sample_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && this->m_iterator != nullptr;
      }
 
      image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      sample* Position() const noexcept
      {
         return this->m_iterator;
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator < this->m_end;
      }
 
      sample& operator *() const noexcept
      {
         return *this->m_iterator;
      }
 
      roi_sample_iterator& operator ++() noexcept
      {
         this->Increment();
         return *this;
      }
 
      roi_sample_iterator operator ++( int ) noexcept
      {
         roi_sample_iterator i0( *this );
         this->Increment();
         return i0;
      }
 
      roi_sample_iterator& operator --() noexcept
      {
         this->Decrement();
         return *this;
      }
 
      roi_sample_iterator operator --( int ) noexcept
      {
         roi_sample_iterator i0( *this );
         this->Decrement();
         return i0;
      }
 
      roi_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( delta%w, delta/w );
         return *this;
      }
 
      roi_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( -delta%w, -delta/w );
         return *this;
      }
 
      roi_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         iterator_base::MoveBy( dx, dy );
         return *this;
      }
 
      friend roi_sample_iterator operator +( const roi_sample_iterator& i, distance_type delta ) noexcept
      {
         roi_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_sample_iterator operator +( distance_type delta, const roi_sample_iterator& i ) noexcept
      {
         roi_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_sample_iterator operator -( const roi_sample_iterator& i, distance_type delta ) noexcept
      {
         roi_sample_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const roi_sample_iterator& i, const roi_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const roi_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const roi_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const roi_sample_iterator& i, const roi_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const roi_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const roi_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
 
      friend class const_roi_pixel_iterator;
   };
 
   // -------------------------------------------------------------------------
 
   class const_roi_sample_iterator : private roi_sample_iterator_base<const GenericImage<P>, const sample*>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using iterator_base = roi_sample_iterator_base<const GenericImage<P>, const sample*>;
 
      const_roi_sample_iterator() = default;
 
      const_roi_sample_iterator( const image_type& image, const Rect& rect = Rect( 0 ), int channel = -1 )
         : iterator_base( image, rect, channel )
      {
      }
 
      const_roi_sample_iterator( const image_type& image, const sample* i, const sample* j )
         : iterator_base( image, i, j )
      {
      }
 
      const_roi_sample_iterator( const roi_sample_iterator& i )
         : iterator_base( i.m_image, i.m_rowBegin, i.m_end )
      {
      }
 
      const_roi_sample_iterator( const const_roi_sample_iterator& ) = default;
 
      const_roi_sample_iterator& operator =( const roi_sample_iterator& i ) noexcept
      {
         this->m_image    = i.m_image;
         this->m_iterator = i.m_iterator;
         this->m_rowBegin = i.m_rowBegin;
         this->m_rowEnd   = i.m_rowEnd;
         this->m_end      = i.m_end;
         return *this;
      }
 
      const_roi_sample_iterator& operator =( const const_roi_sample_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && this->m_iterator != nullptr;
      }
 
      const image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const sample* Position() const noexcept
      {
         return this->m_iterator;
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator < this->m_end;
      }
 
      const sample& operator *() const noexcept
      {
         return *this->m_iterator;
      }
 
      const_roi_sample_iterator& operator ++() noexcept
      {
         this->Increment();
         return *this;
      }
 
      const_roi_sample_iterator operator ++( int ) noexcept
      {
         const_roi_sample_iterator i0( *this );
         this->Increment();
         return i0;
      }
 
      const_roi_sample_iterator& operator --() noexcept
      {
         this->Decrement();
         return *this;
      }
 
      const_roi_sample_iterator operator --( int ) noexcept
      {
         const_roi_sample_iterator i0( *this );
         this->Decrement();
         return i0;
      }
 
      const_roi_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( delta%w, delta/w );
         return *this;
      }
 
      const_roi_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( -delta%w, -delta/w );
         return *this;
      }
 
      const_roi_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         iterator_base::MoveBy( dx, dy );
         return *this;
      }
 
      friend const_roi_sample_iterator operator +( const const_roi_sample_iterator& i, distance_type delta ) noexcept
      {
         const_roi_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_sample_iterator operator +( distance_type delta, const const_roi_sample_iterator& i ) noexcept
      {
         const_roi_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_sample_iterator operator -( const const_roi_sample_iterator& i, distance_type delta ) noexcept
      {
         const_roi_sample_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const const_roi_sample_iterator& i, const const_roi_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const const_roi_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const const_roi_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const const_roi_sample_iterator& i, const const_roi_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const const_roi_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const const_roi_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class image_type, class iterator_base, class sample_pointer, class filter_type>
   class filter_sample_iterator_base : public iterator_base
   {
   protected:
 
      filter_type    m_filter;
      sample_pointer m_begin = nullptr;
 
      filter_sample_iterator_base() = default;
 
      filter_sample_iterator_base( image_type& image, const filter_type& filter, int channel )
         : iterator_base( image, channel )
         , m_filter( filter )
         , m_begin( iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      filter_sample_iterator_base( image_type& image, const filter_type& filter, sample_pointer i, sample_pointer j )
         : iterator_base( image, i, j )
         , m_filter( filter )
         , m_begin( iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      filter_sample_iterator_base( const iterator_base& i, const filter_type& filter )
         : iterator_base( i )
         , m_filter( filter )
         , m_begin( iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      filter_sample_iterator_base( const filter_sample_iterator_base& ) = default;
 
      filter_sample_iterator_base& operator =( const filter_sample_iterator_base& ) = default;
 
      filter_sample_iterator_base& operator =( const iterator_base& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         JumpToNextValidSample();
         return *this;
      }
 
      void JumpToNextValidSample() noexcept
      {
         while ( this->m_iterator < this->m_end && !this->m_filter( *this->m_iterator ) )
            ++this->m_iterator;
      }
 
      void JumpToPrevValidSample() noexcept
      {
         while ( this->m_iterator > this->m_begin && !this->m_filter( *this->m_iterator ) )
            --this->m_iterator;
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class filter_sample_iterator :
      public filter_sample_iterator_base<GenericImage<P>, sample_iterator, sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = filter_sample_iterator_base<GenericImage<P>, sample_iterator, sample*, F>;
 
      filter_sample_iterator() = default;
 
      filter_sample_iterator( image_type& image, const F& filter, int channel = -1 )
         : iterator_base( image.EnsureUnique(), filter, channel )
      {
      }
 
      filter_sample_iterator( image_type& image, const F& filter, sample* i, sample* j )
         : iterator_base( image, filter, i, j )
      {
      }
 
      filter_sample_iterator( const sample_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      filter_sample_iterator( const filter_sample_iterator& i ) = default;
 
      filter_sample_iterator& operator =( const filter_sample_iterator& ) = default;
 
      filter_sample_iterator& operator =( const sample_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && this->m_iterator != nullptr;
      }
 
      image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      sample* Position() const noexcept
      {
         return this->m_iterator;
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator < this->m_end;
      }
 
      sample& operator *() const noexcept
      {
         return *this->m_iterator;
      }
 
      filter_sample_iterator& operator ++() noexcept
      {
         ++this->m_iterator;
         this->JumpToNextValidSample();
         return *this;
      }
 
      filter_sample_iterator operator ++( int ) noexcept
      {
         sample* __restrict__ i0 = this->m_iterator++;
         this->JumpToNextValidSample();
         return filter_sample_iterator( *this->m_image, this->m_filter, i0, this->m_end );
      }
 
      filter_sample_iterator& operator --() noexcept
      {
         --this->m_iterator;
         this->JumpToPrevValidSample();
         return *this;
      }
 
      filter_sample_iterator operator --( int ) noexcept
      {
         sample* __restrict__ i0 = this->m_iterator--;
         this->JumpToPrevValidSample();
         return filter_sample_iterator( *this->m_image, this->m_filter, i0, this->m_end );
      }
 
      filter_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         this->m_iterator += delta;
         this->JumpToNextValidSample();
         return *this;
      }
 
      filter_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         this->m_iterator -= delta;
         this->JumpToPrevValidSample();
         return *this;
      }
 
      filter_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         distance_type d = distance_type( dy )*this->m_image->Width() + distance_type( dx );
         this->m_iterator += d;
         if ( d >= 0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend filter_sample_iterator operator +( const filter_sample_iterator& i, distance_type delta ) noexcept
      {
         return filter_sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend filter_sample_iterator operator +( distance_type delta, const filter_sample_iterator& i ) noexcept
      {
         return filter_sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend filter_sample_iterator operator -( const filter_sample_iterator& i, distance_type delta ) noexcept
      {
         return filter_sample_iterator( *i.m_image, i.m_iterator - delta, i.m_end );
      }
 
      friend distance_type operator -( const filter_sample_iterator& i, const filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator - j.m_iterator;
      }
 
      friend bool operator ==( const filter_sample_iterator& i, const filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const filter_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const filter_sample_iterator& i, const filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const filter_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class const_filter_sample_iterator :
      public filter_sample_iterator_base<const GenericImage<P>, const_sample_iterator, const sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = filter_sample_iterator_base<const GenericImage<P>, const_sample_iterator, const sample*, F>;
 
      const_filter_sample_iterator() = default;
 
      const_filter_sample_iterator( const image_type& image, const F& filter, int channel = -1 )
         : iterator_base( image, filter, channel )
      {
      }
 
      const_filter_sample_iterator( const image_type& image, const F& filter, const sample* i, const sample* j )
         : iterator_base( image, filter, i, j )
      {
      }
 
      const_filter_sample_iterator( const sample_iterator& i, const F& filter )
         : iterator_base( i.m_image, filter, i.m_iterator, i.m_end )
      {
      }
 
      const_filter_sample_iterator( const const_sample_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      const_filter_sample_iterator( const filter_sample_iterator<F>& i )
         : iterator_base( i )
      {
      }
 
      const_filter_sample_iterator( const const_filter_sample_iterator& ) = default;
 
      const_filter_sample_iterator& operator =( const const_filter_sample_iterator& ) = default;
 
      const_filter_sample_iterator& operator =( const sample_iterator& i ) noexcept
      {
         (void)const_sample_iterator::operator =( i );
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_filter_sample_iterator& operator =( const const_sample_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && this->m_iterator != nullptr;
      }
 
      const image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      const sample* Position() const noexcept
      {
         return this->m_iterator;
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator < this->m_end;
      }
 
      const sample& operator *() const noexcept
      {
         return *this->m_iterator;
      }
 
      const_filter_sample_iterator& operator ++() noexcept
      {
         ++this->m_iterator;
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_filter_sample_iterator operator ++( int ) noexcept
      {
         sample* __restrict__ i0 = this->m_iterator++;
         this->JumpToNextValidSample();
         return const_filter_sample_iterator( *this->m_image, this->m_filter, i0, this->m_end );
      }
 
      const_filter_sample_iterator& operator --() noexcept
      {
         --this->m_iterator;
         this->JumpToPrevValidSample();
         return *this;
      }
 
      const_filter_sample_iterator operator --( int ) noexcept
      {
         sample* __restrict__ i0 = this->m_iterator--;
         this->JumpToPrevValidSample();
         return const_filter_sample_iterator( *this->m_image, this->m_filter, i0, this->m_end );
      }
 
      const_filter_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         this->m_iterator += delta;
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_filter_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         this->m_iterator -= delta;
         this->JumpToPrevValidSample();
         return *this;
      }
 
      const_filter_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         distance_type d = distance_type( dy )*this->m_image->Width() + distance_type( dx );
         this->m_iterator += d;
         if ( d >= 0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend const_filter_sample_iterator operator +( const const_filter_sample_iterator& i, distance_type delta ) noexcept
      {
         return const_filter_sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend const_filter_sample_iterator operator +( distance_type delta, const const_filter_sample_iterator& i ) noexcept
      {
         return const_filter_sample_iterator( *i.m_image, i.m_iterator + delta, i.m_end );
      }
 
      friend const_filter_sample_iterator operator -( const const_filter_sample_iterator& i, distance_type delta ) noexcept
      {
         return const_filter_sample_iterator( *i.m_image, i.m_iterator - delta, i.m_end );
      }
 
      friend distance_type operator -( const const_filter_sample_iterator& i, const const_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator - j.m_iterator;
      }
 
      friend bool operator ==( const const_filter_sample_iterator& i, const const_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const const_filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const const_filter_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const const_filter_sample_iterator& i, const const_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const const_filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const const_filter_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class image_type, class sample_pointer, class filter_type>
   class roi_filter_sample_iterator_base : public roi_sample_iterator_base<image_type, sample_pointer>
   {
   protected:
 
      using roi_iterator_base = roi_sample_iterator_base<image_type, sample_pointer>;
 
      filter_type    m_filter;
      sample_pointer m_begin = nullptr;
 
      roi_filter_sample_iterator_base() = default;
 
      roi_filter_sample_iterator_base( image_type& image, const filter_type& filter, const Rect& rect, int channel )
         : roi_iterator_base( image, rect, channel )
         , m_filter( filter )
         , m_begin( roi_iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      roi_filter_sample_iterator_base( image_type& image, const filter_type& filter, sample_pointer i, sample_pointer j )
         : roi_iterator_base( image, i, j )
         , m_filter( filter )
         , m_begin( roi_iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      roi_filter_sample_iterator_base( const roi_iterator_base& i, const filter_type& filter )
         : roi_iterator_base( i )
         , m_filter( filter )
         , m_begin( roi_iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      roi_filter_sample_iterator_base( const roi_filter_sample_iterator_base& ) = default;
 
      roi_filter_sample_iterator_base& operator =( const roi_filter_sample_iterator_base& i ) = default;
 
      roi_filter_sample_iterator_base& operator =( const roi_iterator_base& i ) noexcept
      {
         (void)roi_iterator_base::operator =( i );
         JumpToNextValidSample();
         return *this;
      }
 
      void JumpToNextValidSample() noexcept
      {
         while ( this->m_iterator < this->m_end && !this->m_filter( *this->m_iterator ) )
            roi_iterator_base::Increment();
      }
 
      void JumpToPrevValidSample() noexcept
      {
         while ( this->m_iterator > this->m_begin && !this->m_filter( *this->m_iterator ) )
            roi_iterator_base::Decrement();
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class roi_filter_sample_iterator : public roi_filter_sample_iterator_base<GenericImage<P>, sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = roi_filter_sample_iterator_base<GenericImage<P>, sample*, F>;
 
      roi_filter_sample_iterator() = default;
 
      roi_filter_sample_iterator( image_type& image, const F& filter, const Rect& rect = Rect( 0 ), int channel = -1 )
         : iterator_base( image.EnsureUnique(), filter, rect, channel )
      {
      }
 
      roi_filter_sample_iterator( image_type& image, const F& filter, sample* i, sample* j )
         : iterator_base( image, filter, i, j )
      {
      }
 
      roi_filter_sample_iterator( const roi_sample_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      roi_filter_sample_iterator( const roi_filter_sample_iterator& ) = default;
 
      roi_filter_sample_iterator& operator =( const roi_filter_sample_iterator& ) = default;
 
      roi_filter_sample_iterator& operator =( const roi_sample_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && this->m_iterator != nullptr;
      }
 
      image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      sample* Position() const noexcept
      {
         return this->m_iterator;
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator < this->m_end;
      }
 
      sample& operator *() const noexcept
      {
         return *this->m_iterator;
      }
 
      roi_filter_sample_iterator& operator ++() noexcept
      {
         this->Increment();
         this->JumpToNextValidSample();
         return *this;
      }
 
      roi_filter_sample_iterator operator ++( int ) noexcept
      {
         roi_filter_sample_iterator i0( *this );
         this->Increment();
         this->JumpToNextValidSample();
         return i0;
      }
 
      roi_filter_sample_iterator& operator --() noexcept
      {
         this->Decrement();
         this->JumpToPrevValidSample();
         return *this;
      }
 
      roi_filter_sample_iterator operator --( int ) noexcept
      {
         roi_filter_sample_iterator i0( *this );
         this->Decrement();
         this->JumpToPrevValidSample();
         return i0;
      }
 
      roi_filter_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( delta%w, delta/w );
      }
 
      roi_filter_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( -delta%w, -delta/w );
      }
 
      roi_filter_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         sample* __restrict__ i0 = this->m_iterator;
         iterator_base::MoveBy( dx, dy );
         if ( this->m_iterator >= i0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend roi_filter_sample_iterator operator +( const roi_filter_sample_iterator& i, distance_type delta ) noexcept
      {
         roi_filter_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_filter_sample_iterator operator +( distance_type delta, const roi_filter_sample_iterator& i ) noexcept
      {
         roi_filter_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_filter_sample_iterator operator -( const roi_filter_sample_iterator& i, distance_type delta ) noexcept
      {
         roi_filter_sample_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const roi_filter_sample_iterator& i, const roi_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const roi_filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const roi_filter_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const roi_filter_sample_iterator& i, const roi_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const roi_filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const roi_filter_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class const_roi_filter_sample_iterator : public roi_filter_sample_iterator_base<const GenericImage<P>, const sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = roi_filter_sample_iterator_base<const GenericImage<P>, const sample*, F>;
 
      const_roi_filter_sample_iterator() = default;
 
      const_roi_filter_sample_iterator( const image_type& image, const F& filter, const Rect& rect = Rect( 0 ), int channel = -1 )
         : iterator_base( image, filter, rect, channel )
      {
      }
 
      const_roi_filter_sample_iterator( const image_type& image, const F& filter, const sample* i, const sample* j )
         : iterator_base( image, filter, i, j )
      {
      }
 
      const_roi_filter_sample_iterator( const const_roi_sample_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      const_roi_filter_sample_iterator( const const_roi_filter_sample_iterator& ) = default;
 
      const_roi_filter_sample_iterator& operator =( const const_roi_filter_sample_iterator& ) = default;
 
      const_roi_filter_sample_iterator& operator =( const const_roi_sample_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && this->m_iterator != nullptr;
      }
 
      const image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      const sample* Position() const noexcept
      {
         return this->m_iterator;
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator < this->m_end;
      }
 
      const sample& operator *() const noexcept
      {
         return *this->m_iterator;
      }
 
      const_roi_filter_sample_iterator& operator ++() noexcept
      {
         this->Increment();
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_roi_filter_sample_iterator operator ++( int ) noexcept
      {
         const_roi_filter_sample_iterator i0( *this );
         this->Increment();
         this->JumpToNextValidSample();
         return i0;
      }
 
      const_roi_filter_sample_iterator& operator --() noexcept
      {
         this->Decrement();
         this->JumpToPrevValidSample();
         return *this;
      }
 
      const_roi_filter_sample_iterator operator --( int ) noexcept
      {
         const_roi_filter_sample_iterator i0( *this );
         this->Decrement();
         this->JumpToPrevValidSample();
         return i0;
      }
 
      const_roi_filter_sample_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( delta%w, delta/w );
      }
 
      const_roi_filter_sample_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( -delta%w, -delta/w );
      }
 
      const_roi_filter_sample_iterator& MoveBy( int dx, int dy ) noexcept
      {
         const sample* __restrict__ i0 = this->m_iterator;
         iterator_base::MoveBy( dx, dy );
         if ( this->m_iterator >= i0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend const_roi_filter_sample_iterator operator +( const const_roi_filter_sample_iterator& i, distance_type delta ) noexcept
      {
         const_roi_filter_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_filter_sample_iterator operator +( distance_type delta, const const_roi_filter_sample_iterator& i ) noexcept
      {
         const_roi_filter_sample_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_filter_sample_iterator operator -( const const_roi_filter_sample_iterator& i, distance_type delta ) noexcept
      {
         const_roi_filter_sample_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const const_roi_filter_sample_iterator& i, const const_roi_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator == j.m_iterator;
      }
 
      friend bool operator ==( const const_roi_filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator == j;
      }
 
      friend bool operator ==( const sample* i, const const_roi_filter_sample_iterator& j ) noexcept
      {
         return i == j.m_iterator;
      }
 
      friend bool operator <( const const_roi_filter_sample_iterator& i, const const_roi_filter_sample_iterator& j ) noexcept
      {
         return i.m_iterator < j.m_iterator;
      }
 
      friend bool operator <( const const_roi_filter_sample_iterator& i, const sample* j ) noexcept
      {
         return i.m_iterator < j;
      }
 
      friend bool operator <( const sample* i, const const_roi_filter_sample_iterator& j ) noexcept
      {
         return i < j.m_iterator;
      }
   };
 
   // -------------------------------------------------------------------------
 
   class pixel_iterator
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using iterator_type = GenericVector<sample*>;
 
      pixel_iterator() = default;
 
      pixel_iterator( image_type& image )
         : m_image( &image )
      {
         m_image->EnsureUnique();
         if ( !m_image->IsEmpty() )
         {
            m_iterator = iterator_type( m_image->NumberOfChannels() );
            for ( int i = 0; i < m_iterator.Length(); ++i )
               m_iterator[i] = (*m_image)[i];
            m_end = m_iterator[0] + m_image->NumberOfPixels();
         }
      }
 
      pixel_iterator( const pixel_iterator& ) = default;
 
      pixel_iterator& operator =( const pixel_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return m_image != nullptr && !m_iterator.IsEmpty();
      }
 
      image_type& Image() const noexcept
      {
         return *m_image;
      }
 
      sample* Position( int channel ) const noexcept
      {
         return m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return m_iterator[0] < m_end;
      }
 
      sample& operator []( int channel ) const noexcept
      {
         return *m_iterator[channel];
      }
 
      pixel_iterator& operator ++() noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            ++m_iterator[i];
         return *this;
      }
 
      pixel_iterator operator ++( int ) noexcept
      {
         pixel_iterator i0( *this );
         for ( int i = 0; i < m_iterator.Length(); ++i )
            ++m_iterator[i];
         return i0;
      }
 
      pixel_iterator& operator --() noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            --m_iterator[i];
         return *this;
      }
 
      pixel_iterator operator --( int ) noexcept
      {
         pixel_iterator i0( *this );
         for ( int i = 0; i < m_iterator.Length(); ++i )
            --m_iterator[i];
         return i0;
      }
 
      pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            m_iterator[i] += delta;
         return *this;
      }
 
      pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            m_iterator[i] -= delta;
         return *this;
      }
 
      pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         return operator +=( distance_type( dy )*m_image->Width() + distance_type( dx ) );
      }
 
      friend pixel_iterator operator +( const pixel_iterator& i, distance_type delta ) noexcept
      {
         pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend pixel_iterator operator +( distance_type delta, const pixel_iterator& i ) noexcept
      {
         pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend pixel_iterator operator -( const pixel_iterator& i, distance_type delta ) noexcept
      {
         pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend distance_type operator -( const pixel_iterator& i, const pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] - j.m_iterator[0];
      }
 
      friend bool operator ==( const pixel_iterator& i, const pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const pixel_iterator& i, const pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
 
   protected:
 
            image_type*          m_image = nullptr;
            iterator_type        m_iterator;
      const sample* __restrict__ m_end = nullptr;
   };
 
   // -------------------------------------------------------------------------
 
   class const_pixel_iterator
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using iterator_type = GenericVector<const sample*>;
 
      const_pixel_iterator() = default;
 
      const_pixel_iterator( const image_type& image )
         : m_image( &image )
      {
         if ( !m_image->IsEmpty() )
         {
            m_iterator = iterator_type( m_image->NumberOfChannels() );
            for ( int i = 0; i < m_iterator.Length(); ++i )
               m_iterator[i] = (*m_image)[i];
            m_end = m_iterator[0] + m_image->NumberOfPixels();
         }
      }
 
      const_pixel_iterator( const const_pixel_iterator& ) = default;
 
      const_pixel_iterator& operator =( const const_pixel_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return m_image != nullptr && !m_iterator.IsEmpty();
      }
 
      const image_type& Image() const noexcept
      {
         return *m_image;
      }
 
      const sample* Position( int channel ) const noexcept
      {
         return m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return m_iterator[0] < m_end;
      }
 
      const sample& operator []( int channel ) const noexcept
      {
         return *m_iterator[channel];
      }
 
      const_pixel_iterator& operator ++() noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            ++m_iterator[i];
         return *this;
      }
 
      const_pixel_iterator operator ++( int ) noexcept
      {
         const_pixel_iterator i0( *this );
         for ( int i = 0; i < m_iterator.Length(); ++i )
            ++m_iterator[i];
         return i0;
      }
 
      const_pixel_iterator& operator --() noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            --m_iterator[i];
         return *this;
      }
 
      const_pixel_iterator operator --( int ) noexcept
      {
         const_pixel_iterator i0( *this );
         for ( int i = 0; i < m_iterator.Length(); ++i )
            --m_iterator[i];
         return i0;
      }
 
      const_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            m_iterator[i] += delta;
         return *this;
      }
 
      const_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            m_iterator[i] -= delta;
         return *this;
      }
 
      const_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         return operator +=( distance_type( dy )*m_image->Width() + distance_type( dx ) );
      }
 
      friend const_pixel_iterator operator +( const const_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_pixel_iterator operator +( distance_type delta, const const_pixel_iterator& i ) noexcept
      {
         const_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_pixel_iterator operator -( const const_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend distance_type operator -( const const_pixel_iterator& i, const const_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] - j.m_iterator[0];
      }
 
      friend bool operator ==( const const_pixel_iterator& i, const const_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const const_pixel_iterator& i, const const_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
 
   protected:
 
      const image_type*          m_image = nullptr;
            iterator_type        m_iterator;
      const sample* __restrict__ m_end = nullptr;
   };
 
   // -------------------------------------------------------------------------
 
   template <class image_type, class sample_pointer>
   class roi_pixel_iterator_base
   {
   protected:
 
      using iterator_type = GenericVector<sample_pointer>;
 
      image_type*    m_image = nullptr;
      iterator_type  m_iterator;
      sample_pointer m_rowBegin = nullptr;
      sample_pointer m_rowEnd = nullptr;
      sample_pointer m_end = nullptr;
 
      roi_pixel_iterator_base() = default;
 
      roi_pixel_iterator_base( image_type& image, const Rect& rect )
         : m_image( &image )
      {
         Rect r = rect;
         if ( m_image->ParseRect( r ) )
         {
            m_iterator = iterator_type( m_image->NumberOfChannels() );
            for ( int i = 0; i < m_iterator.Length(); ++i )
               m_iterator[i] = m_image->PixelAddress( r.x0, r.y0, i );
            m_rowBegin = m_iterator[0];
            m_rowEnd = m_rowBegin + r.Width();
            m_end = m_rowEnd + ((r.Height() - 1)*m_image->Width());
         }
      }
 
      roi_pixel_iterator_base( const roi_pixel_iterator_base& ) = default;
 
      roi_pixel_iterator_base& operator =( const roi_pixel_iterator_base& ) = default;
 
      void Increment() noexcept
      {
         for ( int i = 0; i < m_iterator.Length(); ++i )
            ++m_iterator[i];
         if ( m_iterator[0] == m_rowEnd )
         {
            int w = m_rowEnd - m_rowBegin;
            for ( int i = 0; i < m_iterator.Length(); ++i )
               m_iterator[i] += m_image->Width() - w;
            m_rowBegin += m_image->Width();
            m_rowEnd += m_image->Width();
         }
      }
 
      void Decrement() noexcept
      {
         if ( m_iterator[0] == m_rowBegin )
         {
            int w = m_rowEnd - m_rowBegin;
            for ( int i = 0; i < m_iterator.Length(); ++i )
               m_iterator[i] -= m_image->Width() - w;
            m_rowBegin -= m_image->Width();
            m_rowEnd -= m_image->Width();
         }
         for ( int i = 0; i < m_iterator.Length(); ++i )
            --m_iterator[i];
      }
 
      void MoveBy( int cols, int rows ) noexcept
      {
         int dx = m_iterator[0] - m_rowBegin;
         for ( int i = 0; i < m_iterator.Length(); ++i )
            m_iterator[i] -= dx;
         cols += dx;
         if ( cols != 0 )
         {
            int w = m_rowEnd - m_rowBegin;
            if ( pcl::Abs( cols ) >= w )
            {
               rows += cols/w;
               cols %= w;
            }
         }
         int dy = rows * m_image->Width();
         for ( int i = 0; i < m_iterator.Length(); ++i )
            m_iterator[i] += dy + cols;
         m_rowBegin += dy;
         m_rowEnd += dy;
      }
   };
 
   // -------------------------------------------------------------------------
 
   class roi_pixel_iterator : private roi_pixel_iterator_base<GenericImage<P>, sample*>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using iterator_base = roi_pixel_iterator_base<GenericImage<P>, sample*>;
 
      roi_pixel_iterator() = default;
 
      roi_pixel_iterator( image_type& image, const Rect& rect = Rect( 0 ) )
         : iterator_base( image.EnsureUnique(), rect )
      {
      }
 
      roi_pixel_iterator( const roi_pixel_iterator& ) = default;
 
      roi_pixel_iterator& operator =( const roi_pixel_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && !this->m_iterator.IsEmpty();
      }
 
      image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      sample* Position( int channel ) const noexcept
      {
         return this->m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator[0] < this->m_end;
      }
 
      sample& operator []( int channel ) const noexcept
      {
         return *this->m_iterator[channel];
      }
 
      roi_pixel_iterator& operator ++() noexcept
      {
         this->Increment();
         return *this;
      }
 
      roi_pixel_iterator operator ++( int ) noexcept
      {
         roi_pixel_iterator i0( *this );
         this->Increment();
         return i0;
      }
 
      roi_pixel_iterator& operator --() noexcept
      {
         this->Decrement();
         return *this;
      }
 
      roi_pixel_iterator operator --( int ) noexcept
      {
         roi_pixel_iterator i0( *this );
         this->Decrement();
         return i0;
      }
 
      roi_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( delta%w, delta/w );
         return *this;
      }
 
      roi_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( -delta%w, -delta/w );
         return *this;
      }
 
      roi_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         iterator_base::MoveBy( dx, dy );
         return *this;
      }
 
      friend roi_pixel_iterator operator +( const roi_pixel_iterator& i, distance_type delta ) noexcept
      {
         roi_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_pixel_iterator operator +( distance_type delta, const roi_pixel_iterator& i ) noexcept
      {
         roi_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_pixel_iterator operator -( const roi_pixel_iterator& i, distance_type delta ) noexcept
      {
         roi_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const roi_pixel_iterator& i, const roi_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const roi_pixel_iterator& i, const roi_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
   };
 
   // -------------------------------------------------------------------------
 
   class const_roi_pixel_iterator : private roi_pixel_iterator_base<const GenericImage<P>, const sample*>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using iterator_base = roi_pixel_iterator_base<const GenericImage<P>, const sample*>;
 
      const_roi_pixel_iterator() = default;
 
      const_roi_pixel_iterator( const image_type& image, const Rect& rect = Rect( 0 ) )
         : iterator_base( image, rect )
      {
      }
 
      const_roi_pixel_iterator( const const_roi_pixel_iterator& ) = default;
 
      const_roi_pixel_iterator& operator =( const const_roi_pixel_iterator& ) = default;
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && !this->m_iterator.IsEmpty();
      }
 
      const image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const sample* Position( int channel ) const noexcept
      {
         return this->m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator[0] < this->m_end;
      }
 
      const sample& operator []( int channel ) const noexcept
      {
         return *this->m_iterator[channel];
      }
 
      const_roi_pixel_iterator& operator ++() noexcept
      {
         this->Increment();
         return *this;
      }
 
      const_roi_pixel_iterator operator ++( int ) noexcept
      {
         const_roi_pixel_iterator i0( *this );
         this->Increment();
         return i0;
      }
 
      const_roi_pixel_iterator& operator --() noexcept
      {
         this->Decrement();
         return *this;
      }
 
      const_roi_pixel_iterator operator --( int ) noexcept
      {
         const_roi_pixel_iterator i0( *this );
         this->Decrement();
         return i0;
      }
 
      const_roi_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( delta%w, delta/w );
         return *this;
      }
 
      const_roi_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         iterator_base::MoveBy( -delta%w, -delta/w );
         return *this;
      }
 
      const_roi_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         iterator_base::MoveBy( dx, dy );
         return *this;
      }
 
      friend const_roi_pixel_iterator operator +( const const_roi_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_roi_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_pixel_iterator operator +( distance_type delta, const const_roi_pixel_iterator& i ) noexcept
      {
         const_roi_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_pixel_iterator operator -( const const_roi_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_roi_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const const_roi_pixel_iterator& i, const const_roi_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const const_roi_pixel_iterator& i, const const_roi_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class image_type, class iterator_base, class sample_pointer, class filter_type>
   class filter_pixel_iterator_base : public iterator_base
   {
   protected:
 
      filter_type    m_filter;
      sample_pointer m_begin = nullptr;
 
      filter_pixel_iterator_base() = default;
 
      filter_pixel_iterator_base( image_type& image, const filter_type& filter )
         : iterator_base( image )
         , m_filter( filter )
         , m_begin( iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      filter_pixel_iterator_base( const iterator_base& i, const filter_type& filter )
         : iterator_base( i )
         , m_filter( filter )
         , m_begin( iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      filter_pixel_iterator_base( const filter_pixel_iterator_base& ) = default;
 
      filter_pixel_iterator_base& operator =( const filter_pixel_iterator_base& ) = default;
 
      filter_pixel_iterator_base& operator =( const iterator_base& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         JumpToNextValidSample();
      }
 
      void JumpToNextValidSample() noexcept
      {
         while ( this->m_iterator[0] < this->m_end && !this->m_filter( this->m_iterator ) )
            for ( int i = 0; i < this->m_iterator.Length(); ++i )
               ++this->m_iterator[i];
      }
 
      void JumpToPrevValidSample() noexcept
      {
         while ( this->m_iterator[0] > this->m_begin && !this->m_filter( this->m_iterator ) )
            for ( int i = 0; i < this->m_iterator.Length(); ++i )
               --this->m_iterator[i];
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class filter_pixel_iterator :
      public filter_pixel_iterator_base<GenericImage<P>, pixel_iterator, sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = filter_pixel_iterator_base<GenericImage<P>, pixel_iterator, sample*, F>;
 
      filter_pixel_iterator() = default;
 
      filter_pixel_iterator( image_type& image, const F& filter )
         : iterator_base( image.EnsureUnique(), filter )
      {
      }
 
      filter_pixel_iterator( const pixel_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      filter_pixel_iterator( const filter_pixel_iterator& ) = default;
 
      filter_pixel_iterator& operator =( const filter_pixel_iterator& ) = default;
 
      filter_pixel_iterator& operator =( const pixel_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && !this->m_iterator.IsEmpty();
      }
 
      image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      sample* Position( int channel ) const noexcept
      {
         return this->m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator[0] < this->m_end;
      }
 
      sample& operator []( int channel ) const noexcept
      {
         return *this->m_iterator[channel];
      }
 
      filter_pixel_iterator& operator ++() noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            ++this->m_iterator[i];
         this->JumpToNextValidSample();
         return *this;
      }
 
      filter_pixel_iterator operator ++( int ) noexcept
      {
         filter_pixel_iterator i0( *this );
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            ++this->m_iterator[i];
         this->JumpToNextValidSample();
         return i0;
      }
 
      filter_pixel_iterator& operator --() noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            --this->m_iterator[i];
         this->JumpToPrevValidSample();
         return *this;
      }
 
      filter_pixel_iterator operator --( int ) noexcept
      {
         filter_pixel_iterator i0( *this );
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            --this->m_iterator[i];
         this->JumpToPrevValidSample();
         return i0;
      }
 
      filter_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            this->m_iterator[i] += delta;
         this->JumpToNextValidSample();
         return *this;
      }
 
      filter_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            this->m_iterator[i] -= delta;
         this->JumpToPrevValidSample();
         return *this;
      }
 
      filter_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         distance_type d = distance_type( dy )*this->m_image->Width() + distance_type( dx );
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            this->m_iterator[i] += d;
         if ( d >= 0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend filter_pixel_iterator operator +( const filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend filter_pixel_iterator operator +( distance_type delta, const filter_pixel_iterator& i ) noexcept
      {
         filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend filter_pixel_iterator operator -( const filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         filter_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const filter_pixel_iterator& i, const filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const filter_pixel_iterator& i, const filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class const_filter_pixel_iterator :
      public filter_pixel_iterator_base<const GenericImage<P>, const_pixel_iterator, const sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = filter_pixel_iterator_base<const GenericImage<P>, const_pixel_iterator, const sample*, F>;
 
      const_filter_pixel_iterator() = default;
 
      const_filter_pixel_iterator( const image_type& image, const F& filter )
         : iterator_base( image, filter )
      {
      }
 
      const_filter_pixel_iterator( const const_pixel_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      const_filter_pixel_iterator( const const_filter_pixel_iterator& ) = default;
 
      const_filter_pixel_iterator& operator =( const const_filter_pixel_iterator& ) = default;
 
      const_filter_pixel_iterator& operator =( const const_pixel_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && !this->m_iterator.IsEmpty();
      }
 
      const image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      const sample* Position( int channel ) const noexcept
      {
         return this->m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator[0] < this->m_end;
      }
 
      const sample& operator []( int channel ) const noexcept
      {
         return *this->m_iterator[channel];
      }
 
      const_filter_pixel_iterator& operator ++() noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            ++this->m_iterator[i];
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_filter_pixel_iterator operator ++( int ) noexcept
      {
         const_filter_pixel_iterator i0( *this );
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            ++this->m_iterator[i];
         this->JumpToNextValidSample();
         return i0;
      }
 
      const_filter_pixel_iterator& operator --() noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            --this->m_iterator[i];
         this->JumpToPrevValidSample();
         return *this;
      }
 
      const_filter_pixel_iterator operator --( int ) noexcept
      {
         const_filter_pixel_iterator i0( *this );
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            --this->m_iterator[i];
         this->JumpToPrevValidSample();
         return i0;
      }
 
      const_filter_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            this->m_iterator[i] += delta;
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_filter_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            this->m_iterator[i] -= delta;
         this->JumpToPrevValidSample();
         return *this;
      }
 
      const_filter_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         distance_type d = distance_type( dy )*this->m_image->Width() + distance_type( dx );
         for ( int i = 0; i < this->m_iterator.Length(); ++i )
            this->m_iterator[i] += d;
         if ( d >= 0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend const_filter_pixel_iterator operator +( const const_filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_filter_pixel_iterator operator +( distance_type delta, const const_filter_pixel_iterator& i ) noexcept
      {
         const_filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_filter_pixel_iterator operator -( const const_filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_filter_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const const_filter_pixel_iterator& i, const const_filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const const_filter_pixel_iterator& i, const const_filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class image_type, class sample_pointer, class filter_type>
   class roi_filter_pixel_iterator_base : public roi_pixel_iterator_base<image_type, sample_pointer>
   {
   protected:
 
      using roi_iterator_base = roi_pixel_iterator_base<image_type, sample_pointer>;
 
      filter_type    m_filter;
      sample_pointer m_begin = nullptr;
 
      roi_filter_pixel_iterator_base() = default;
 
      roi_filter_pixel_iterator_base( image_type& image, const filter_type& filter, const Rect& rect )
         : roi_iterator_base( image, rect )
         , m_filter( filter )
         , m_begin( roi_iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      roi_filter_pixel_iterator_base( const roi_iterator_base& i, const filter_type& filter )
         : roi_iterator_base( i )
         , m_filter( filter )
         , m_begin( roi_iterator_base::m_iterator )
      {
         JumpToNextValidSample();
      }
 
      roi_filter_pixel_iterator_base( const roi_filter_pixel_iterator_base& ) = default;
 
      roi_filter_pixel_iterator_base& operator =( const roi_filter_pixel_iterator_base& ) = default;
 
      roi_filter_pixel_iterator_base& operator =( const roi_iterator_base& i ) noexcept
      {
         (void)roi_iterator_base::operator =( i );
         JumpToNextValidSample();
         return *this;
      }
 
      void JumpToNextValidSample() noexcept
      {
         while ( this->m_iterator[0] < this->m_end && !this->m_filter( this->m_iterator ) )
            roi_iterator_base::Increment();
      }
 
      void JumpToPrevValidSample() noexcept
      {
         while ( this->m_iterator[0] > this->m_begin && !this->m_filter( this->m_iterator ) )
            roi_iterator_base::Decrement();
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class roi_filter_pixel_iterator : public roi_filter_pixel_iterator_base<GenericImage<P>, sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = roi_filter_pixel_iterator_base<GenericImage<P>, sample*, F>;
 
      roi_filter_pixel_iterator() = default;
 
      roi_filter_pixel_iterator( image_type& image, const F& filter, const Rect& rect = Rect( 0 ) )
         : iterator_base( image.EnsureUnique(), filter, rect )
      {
      }
 
      roi_filter_pixel_iterator( const roi_pixel_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      roi_filter_pixel_iterator( const roi_filter_pixel_iterator& ) = default;
 
      roi_filter_pixel_iterator& operator =( const roi_filter_pixel_iterator& ) = default;
 
      roi_filter_pixel_iterator& operator =( const roi_pixel_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && !this->m_iterator.IsEmpty();
      }
 
      image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      sample* Position( int channel ) const noexcept
      {
         return this->m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator[0] < this->m_end;
      }
 
      sample& operator []( int channel ) const noexcept
      {
         return *this->m_iterator[channel];
      }
 
      roi_filter_pixel_iterator& operator ++() noexcept
      {
         this->Increment();
         this->JumpToNextValidSample();
         return *this;
      }
 
      roi_filter_pixel_iterator operator ++( int ) noexcept
      {
         roi_filter_pixel_iterator i0( *this );
         this->Increment();
         this->JumpToNextValidSample();
         return i0;
      }
 
      roi_filter_pixel_iterator& operator --() noexcept
      {
         this->Decrement();
         this->JumpToPrevValidSample();
         return *this;
      }
 
      roi_filter_pixel_iterator operator --( int ) noexcept
      {
         roi_filter_pixel_iterator i0( *this );
         this->Decrement();
         this->JumpToPrevValidSample();
         return i0;
      }
 
      roi_filter_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( delta%w, delta/w );
      }
 
      roi_filter_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( -delta%w, -delta/w );
      }
 
      roi_filter_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         sample* __restrict__ i0 = this->m_iterator[0];
         iterator_base::MoveBy( dx, dy );
         if ( this->m_iterator[0] >= i0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend roi_filter_pixel_iterator operator +( const roi_filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         roi_filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_filter_pixel_iterator operator +( distance_type delta, const roi_filter_pixel_iterator& i ) noexcept
      {
         roi_filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend roi_filter_pixel_iterator operator -( const roi_filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         roi_filter_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const roi_filter_pixel_iterator& i, const roi_filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const roi_filter_pixel_iterator& i, const roi_filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
   };
 
   // -------------------------------------------------------------------------
 
   template <class F>
   class const_roi_filter_pixel_iterator : public roi_filter_pixel_iterator_base<const GenericImage<P>, const sample*, F>
   {
   public:
 
      using image_type = GenericImage<P>;
 
      using pixel_traits = typename image_type::pixel_traits;
 
      using sample = typename image_type::sample;
 
      using filter_type = F;
 
      using iterator_base = roi_filter_pixel_iterator_base<const GenericImage<P>, const sample*, F>;
 
      const_roi_filter_pixel_iterator() = default;
 
      const_roi_filter_pixel_iterator( const image_type& image, const F& filter, const Rect& rect = Rect( 0 ) )
         : iterator_base( image, filter, rect )
      {
      }
 
      const_roi_filter_pixel_iterator( const const_roi_pixel_iterator& i, const F& filter )
         : iterator_base( i, filter )
      {
      }
 
      const_roi_filter_pixel_iterator( const const_roi_filter_pixel_iterator& ) = default;
 
 
      const_roi_filter_pixel_iterator& operator =( const const_roi_filter_pixel_iterator& ) = default;
 
      const_roi_filter_pixel_iterator& operator =( const const_roi_pixel_iterator& i ) noexcept
      {
         (void)iterator_base::operator =( i );
         return *this;
      }
 
      bool IsValid() const noexcept
      {
         return this->m_image != nullptr && !this->m_iterator.IsEmpty();
      }
 
      const image_type& Image() const noexcept
      {
         return *this->m_image;
      }
 
      const filter_type& Filter() const noexcept
      {
         return this->m_filter;
      }
 
      filter_type& Filter() noexcept
      {
         return this->m_filter;
      }
 
      const sample* Position( int channel ) const noexcept
      {
         return this->m_iterator[channel];
      }
 
      operator bool() const noexcept
      {
         return this->m_iterator[0] < this->m_end;
      }
 
      const sample& operator []( int channel ) const noexcept
      {
         return *this->m_iterator[channel];
      }
 
      const_roi_filter_pixel_iterator& operator ++() noexcept
      {
         this->Increment();
         this->JumpToNextValidSample();
         return *this;
      }
 
      const_roi_filter_pixel_iterator operator ++( int ) noexcept
      {
         const_roi_filter_pixel_iterator i0( *this );
         this->Increment();
         this->JumpToNextValidSample();
         return i0;
      }
 
      const_roi_filter_pixel_iterator& operator --() noexcept
      {
         this->Decrement();
         this->JumpToPrevValidSample();
         return *this;
      }
 
      const_roi_filter_pixel_iterator operator --( int ) noexcept
      {
         const_roi_filter_pixel_iterator i0( *this );
         this->Decrement();
         this->JumpToPrevValidSample();
         return i0;
      }
 
      const_roi_filter_pixel_iterator& operator +=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( delta%w, delta/w );
      }
 
      const_roi_filter_pixel_iterator& operator -=( distance_type delta ) noexcept
      {
         int w = this->m_rowEnd - this->m_rowBegin;
         return MoveBy( -delta%w, -delta/w );
      }
 
      const_roi_filter_pixel_iterator& MoveBy( int dx, int dy ) noexcept
      {
         const sample* __restrict__ i0 = this->m_iterator[0];
         iterator_base::MoveBy( dx, dy );
         if ( this->m_iterator[0] >= i0 )
            this->JumpToNextValidSample();
         else
            this->JumpToPrevValidSample();
         return *this;
      }
 
      friend const_roi_filter_pixel_iterator operator +( const const_roi_filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_roi_filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_filter_pixel_iterator operator +( distance_type delta, const const_roi_filter_pixel_iterator& i ) noexcept
      {
         const_roi_filter_pixel_iterator j( i );
         j += delta;
         return j;
      }
 
      friend const_roi_filter_pixel_iterator operator -( const const_roi_filter_pixel_iterator& i, distance_type delta ) noexcept
      {
         const_roi_filter_pixel_iterator j( i );
         j -= delta;
         return j;
      }
 
      friend bool operator ==( const const_roi_filter_pixel_iterator& i, const const_roi_filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] == j.m_iterator[0];
      }
 
      friend bool operator <( const const_roi_filter_pixel_iterator& i, const const_roi_filter_pixel_iterator& j ) noexcept
      {
         return i.m_iterator[0] < j.m_iterator[0];
      }
   };
 
   // -------------------------------------------------------------------------
 
   static bool IsFloatSample() noexcept
   {
      return pixel_traits::IsFloatSample();
   }
 
   static bool IsComplexSample() noexcept
   {
      return pixel_traits::IsComplexSample();
   }
 
   static int BytesPerSample() noexcept
   {
      return P::BytesPerSample();
   }
 
   static int BitsPerSample() noexcept
   {
      return P::BitsPerSample();
   }
 
   template <class P1>
   bool SameSampleType( const GenericImage<P1>& image ) const noexcept
   {
      return image.BitsPerSample() == BitsPerSample() &&
             image.IsFloatSample() == IsFloatSample() &&
             image.IsComplexSample() == IsComplexSample();
   }
 
   bool SameSampleType( const GenericImage& image ) const noexcept
   {
      return true;
   }
 
   // -------------------------------------------------------------------------
 
   GenericImage()
   {
      m_data = new Data( this );
   }
 
   GenericImage( const GenericImage& image )
   {
      if ( !image.IsShared() )
         if ( image.IsCompletelySelected() )
         {
            image.m_data->Attach( this );
            m_data = image.m_data;
            m_status = image.m_status;
            ResetSelections();
            return;
         }
 
      m_data = new Data( this );
      (void)Assign( image );
   }
 
   GenericImage( GenericImage&& image )
      : AbstractImage( image )
      , m_data( image.m_data )
   {
      image.m_data = nullptr;
   }
 
   template <class P1>
   GenericImage( const GenericImage<P1>& image )
   {
      m_data = new Data( this );
      (void)Assign( image );
   }
 
   template <class P1>
   GenericImage( const GenericImage<P1>& image, const Rect& rect, int firstChannel = -1, int lastChannel = -1 )
   {
      m_data = new Data( this );
      (void)Assign( image, rect, firstChannel, lastChannel );
   }
 
   GenericImage( int width, int height, color_space colorSpace = ColorSpace::Gray )
   {
      m_data = new Data( this );
      m_data->Allocate( width, height, ColorSpace::NumberOfNominalChannels( colorSpace ), colorSpace );
      ResetSelections();
   }
 
   explicit GenericImage( File& stream )
   {
      m_data = new Data( this );
      Read( stream );
   }
 
   explicit GenericImage( void* handle )
   {
      m_data = new Data( this, handle );
      ResetSelections();
   }
 
   GenericImage( void*, int width, int height, color_space colorSpace = ColorSpace::Gray )
   {
      m_data = new Data( this, width, height, ColorSpace::NumberOfNominalChannels( colorSpace ), colorSpace );
      ResetSelections();
   }
 
   ~GenericImage() override
   {
      if ( m_data != nullptr )
      {
         DetachFromData();
         m_data = nullptr;
      }
   }
 
   // -------------------------------------------------------------------------
 
   bool IsShared() const noexcept
   {
      return m_data->IsShared();
   }
 
   bool IsUnique() const noexcept
   {
      return m_data->IsUnique();
   }
 
   GenericImage& EnsureLocal()
   {
      if ( m_data->IsShared() )
      {
         GenericImage local_;
         GenericImage* local = &local_; // ### Workaround to GCC 7's 'dereferencing type-punned pointer' bugs
         local->m_data->Allocate( m_width, m_height, m_numberOfChannels, m_colorSpace );
         local->m_RGBWS = m_RGBWS;
         local->m_selected = m_selected;
         local->m_savedSelections = m_savedSelections;
         local->m_status = m_status;
         for ( int c = 0; c < m_numberOfChannels; ++c )
            P::Copy( (*local)[c], m_channelData( c ), NumberOfPixels() );
 
         local->m_data->Attach( this );
         DetachFromData();
         m_data = local->m_data;
      }
      return *this;
   }
 
   GenericImage& EnsureUnique()
   {
      if ( !m_data->IsUnique() )
      {
         Data* newData = m_data->Clone( this );
         DetachFromData();
         m_data = newData;
      }
      return *this;
   }
 
   pixel_allocator& Allocator() const noexcept
   {
      return m_allocator;
   }
 
   void Synchronize()
   {
      m_data->SynchronizeWithSharedImage();
      ResetSelections();
   }
 
   GenericImage& AllocateData( int width, int height,
                               int numberOfChannels = 1,
                               color_space colorSpace = ColorSpace::Gray )
   {
      if ( !m_data->IsUnique() )
      {
         Data* newData = new Data( this );
         DetachFromData();
         m_data = newData;
      }
      m_data->Allocate( width, height, numberOfChannels, colorSpace );
      ResetSelections();
      return *this;
   }
 
   GenericImage& AllocateData( const Rect& rect,
                               int numberOfChannels = 1,
                               color_space colorSpace = ColorSpace::Gray )
   {
      return AllocateData( rect.Width(), rect.Height(), numberOfChannels, colorSpace );
   }
 
   GenericImage& FreeData()
   {
      if ( !m_data->IsEmpty() )
         if ( m_data->IsUnique() )
            m_data->Deallocate();
         else
         {
            Data* newData = new Data( this );
            DetachFromData();
            m_data = newData;
         }
      ResetSelections();
      return *this;
   }
 
   GenericImage& ImportData( sample** data, int width, int height,
                             int numberOfChannels = 1, color_space colorSpace = ColorSpace::Gray )
   {
      if ( !m_data->IsUnique() )
      {
         if ( m_data->IsShared() )
            throw Error( "GenericImage::ImportData(): Invalid operation for an aliased shared image" );
         Data* newData = new Data( this );
         DetachFromData();
         m_data = newData;
      }
      m_data->Import( data, width, height, numberOfChannels, colorSpace );
      ResetSelections();
      return *this;
   }
 
   sample** ReleaseData()
   {
      if ( !m_data->IsUnique() )
         throw Error( "GenericImage::ReleaseData(): Invalid operation for an aliased image" );
      sample** data = m_data->Release();
      ResetSelections();
      return data;
   }
 
   // -------------------------------------------------------------------------
 
   size_type LineSize() const noexcept
   {
      return BytesPerSample() * size_type( m_width );
   }
 
   size_type ChannelSize() const noexcept
   {
      return BytesPerSample() * NumberOfPixels();
   }
 
   size_type ImageSize() const noexcept
   {
      return ChannelSize() * size_type( m_numberOfChannels );
   }
 
   size_type NominalSize() const noexcept
   {
      return ChannelSize() * NumberOfNominalChannels();
   }
 
   size_type AlphaSize() const noexcept
   {
      return ChannelSize() * NumberOfAlphaChannels();
   }
 
   sample* PixelData( int channel = 0 )
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      EnsureUnique();
      return m_channelData( channel );
   }
 
   const sample* PixelData( int channel = 0 ) const noexcept
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      return m_channelData( channel );
   }
 
   operator bool() const noexcept
   {
      return m_data != nullptr && !m_data->IsEmpty();
   }
 
   sample* operator []( int channel )
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      return PixelData( channel );
   }
 
   const sample* operator []( int channel ) const noexcept
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      return PixelData( channel );
   }
 
   sample* operator *()
   {
      PCL_PRECONDITION( 0 < m_numberOfChannels )
      return PixelData( 0 );
   }
 
   const sample* operator *() const noexcept
   {
      PCL_PRECONDITION( 0 < m_numberOfChannels )
      return PixelData( 0 );
   }
 
   sample* ScanLine( int y, int channel = 0 )
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      PCL_PRECONDITION( 0 <= y && y < m_height )
      EnsureUnique();
      return m_channelData( channel ) + RowOffset( y );
   }
 
   const sample* ScanLine( int y, int channel = 0 ) const noexcept
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      PCL_PRECONDITION( 0 <= y && y < m_height )
      return m_channelData( channel ) + RowOffset( y );
   }
 
   sample* PixelAddress( int x, int y, int channel = 0 )
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      PCL_PRECONDITION( 0 <= x && x < m_width )
      PCL_PRECONDITION( 0 <= y && y < m_height )
      EnsureUnique();
      return m_channelData( channel ) + PixelOffset( x, y );
   }
 
   const sample* PixelAddress( int x, int y, int channel = 0 ) const noexcept
   {
      PCL_PRECONDITION( 0 <= channel && channel < m_numberOfChannels )
      PCL_PRECONDITION( 0 <= x && x < m_width )
      PCL_PRECONDITION( 0 <= y && y < m_height )
      return m_channelData( channel ) + PixelOffset( x, y );
   }
 
   sample* PixelAddress( const Point& p, int channel = 0 )
   {
      return PixelAddress( p.x, p.y, channel );
   }
 
   const sample* PixelAddress( const Point& p, int channel = 0 ) const noexcept
   {
      return PixelAddress( p.x, p.y, channel );
   }
 
   sample& operator ()( int x, int y, int channel = 0 )
   {
      return *PixelAddress( x, y, channel );
   }
 
   sample operator ()( int x, int y, int channel = 0 ) const noexcept
   {
      return *PixelAddress( x, y, channel );
   }
 
   sample& operator ()( const Point& p, int channel = 0 )
   {
      return *PixelAddress( p, channel );
   }
 
   sample operator ()( const Point& p, int channel = 0 ) const noexcept
   {
      return *PixelAddress( p, channel );
   }
 
   sample& Pixel( int x, int y, int channel = 0 )
   {
      return operator()( x, y, channel );
   }
 
   sample Pixel( int x, int y, int channel = 0 ) const noexcept
   {
      return operator()( x, y, channel );
   }
 
   sample& Pixel( const Point& p, int channel = 0 )
   {
      return operator()( p, channel );
   }
 
   sample Pixel( const Point& p, int channel = 0 ) const noexcept
   {
      return operator()( p, channel );
   }
 
   // -------------------------------------------------------------------------
 
   void SetRGBWorkingSpace( const RGBColorSystem& RGBWS ) override
   {
      if ( !IsShared() )
      {
         EnsureUnique();
         m_RGBWS = RGBWS;
      }
   }
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   GenericImage& Assign( const GenericImage<P1>& image,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      m_status = image.Status();
 
      Rect r = rect;
      if ( !image.ParseSelection( r, firstChannel, lastChannel ) )
      {
         FreeData();
         return *this;
      }
 
      int n = 1 + lastChannel - firstChannel;
      AllocateData( r, n, (firstChannel == 0 && n >= ColorSpace::NumberOfNominalChannels( image.ColorSpace() )) ?
                           image.ColorSpace() : ColorSpace::Gray );
 
      if ( !IsShared() ) // ### cannot modify a shared image's RGBWS
         m_RGBWS = image.RGBWorkingSpace();
 
      ResetSelections();
 
      if ( r == image.Bounds() )
         for ( int c = 0; firstChannel <= lastChannel; ++c, ++firstChannel )
            P::Copy( m_channelData( c ), image[firstChannel], NumberOfPixels() );
      else
         for ( int c = 0; firstChannel <= lastChannel; ++c, ++firstChannel )
         {
            sample* f = m_channelData( c );
            const typename P1::sample* g = image.PixelAddress( r.LeftTop(), firstChannel );
            for ( int y = 0; y < m_height; ++y, f += m_width, g += image.Width() )
               P::Copy( f, g, m_width );
         }
 
      return *this;
   }
 
   GenericImage& Assign( const GenericImage& image,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      m_status = image.Status();
 
      Rect r = rect;
      if ( !image.ParseSelection( r, firstChannel, lastChannel ) )
      {
         FreeData();
         return *this;
      }
 
#define completeSelection  (firstChannel == 0 && lastChannel == image.m_numberOfChannels-1 && r == image.Bounds())
 
      if ( m_data == image.m_data )
      {
         // Self-assignment
         if ( !completeSelection )
         {
            GenericImage result( image, r, firstChannel, lastChannel ); // ### implicit recursion
            result.m_data->Attach( this );
            DetachFromData();
            m_data = result.m_data;
         }
         ResetSelections();
         return *this;
      }
 
      if ( !IsShared() )
         if ( !image.IsShared() )
            if ( completeSelection )
            {
               image.m_data->Attach( this );
               DetachFromData();
               m_data = image.m_data;
               ResetSelections();
               return *this;
            }
 
#undef completeSelection
 
      int n = 1 + lastChannel - firstChannel;
      AllocateData( r, n, (firstChannel == 0 && n >= ColorSpace::NumberOfNominalChannels( image.ColorSpace() )) ?
                           image.ColorSpace() : ColorSpace::Gray );
 
      if ( !IsShared() ) // ### cannot modify a shared image's RGBWS
         m_RGBWS = image.m_RGBWS;
 
      ResetSelections();
 
      if ( r == image.Bounds() )
         for ( int c = 0; firstChannel <= lastChannel; ++c, ++firstChannel )
            P::Copy( m_channelData( c ), image[firstChannel], NumberOfPixels() );
      else
         for ( int c = 0; firstChannel <= lastChannel; ++c, ++firstChannel )
         {
            sample* f = m_channelData( c );
            const sample* g = image.PixelAddress( r.LeftTop(), firstChannel );
            for ( int y = 0; y < m_height; ++y, f += m_width, g += image.m_width )
               P::Copy( f, g, m_width );
         }
 
      return *this;
   }
 
   template <class P1>
   GenericImage& operator =( const GenericImage<P1>& image )
   {
      return Assign( image );
   }
 
   GenericImage& operator =( const GenericImage& image )
   {
      return Assign( image );
   }
 
#define TRANSFER_BODY()                            \
      if ( m_data != image.m_data )                \
      {                                            \
         DetachFromData();                         \
         m_data = image.m_data;                    \
         (void)AbstractImage::operator =( image ); \
         image.m_data = nullptr;                   \
      }                                            \
      return *this
 
   GenericImage& Transfer( GenericImage& image )
   {
      TRANSFER_BODY();
   }
 
   GenericImage& Transfer( GenericImage&& image )
   {
      TRANSFER_BODY();
   }
 
#undef TRANSFER_BODY
 
   GenericImage& operator =( GenericImage&& image )
   {
      return Transfer( image );
   }
 
   GenericImage& operator =( sample scalar )
   {
      return Fill( scalar );
   }
 
   friend void Swap( GenericImage& x1, GenericImage& x2 ) noexcept
   {
      x1.AbstractImage::Swap( x2 );
      pcl::Swap( x1.m_data, x2.m_data );
   }
 
   // -------------------------------------------------------------------------
 
#ifndef __PCL_NO_VECTOR_IMAGE_CONVERSION
 
   sample_vector RowVector( int y, int channel = -1 ) const
   {
      if ( channel < 0 )
         channel = m_channel;
      if ( y < 0 || y >= m_height || channel < 0 || channel >= m_numberOfChannels )
         return sample_vector();
      sample_vector row( m_width );
      P::Get( row.Begin(), ScanLine( y, channel ), m_width );
      return row;
   }
 
   sample_vector ColumnVector( int x, int channel = -1 ) const
   {
      if ( channel < 0 )
         channel = m_channel;
      if ( x < 0 || x >= m_width || channel < 0 || channel >= m_numberOfChannels )
         return sample_vector();
      sample_vector col( m_height );
      const sample* v = PixelAddress( x, 0, channel );
      for ( int y = 0; y < m_height; ++y, v += m_width )
         col[y] = *v;
      return col;
   }
 
   sample_vector ColVector( int x, int channel = 0 ) const
   {
      return ColumnVector( x, channel );
   }
 
#endif   // !__PCL_NO_VECTOR_IMAGE_CONVERSION
 
   template <typename T>
   void GetRow( T* buffer, int y, int channel = -1 ) const
   {
      PCL_PRECONDITION( buffer != nullptr )
      if ( channel < 0 )
         channel = m_channel;
      if ( y >= 0 && y < m_height && channel >= 0 && channel < m_numberOfChannels )
         P::Get( buffer, ScanLine( y, channel ), m_width );
   }
 
   template <typename T>
   void GetColumn( T* buffer, int x, int channel = -1 ) const
   {
      PCL_PRECONDITION( buffer != nullptr )
      if ( channel < 0 )
         channel = m_channel;
      if ( x >= 0 && x < m_width && channel >= 0 && channel < m_numberOfChannels )
      {
         const sample* v = PixelAddress( x, 0, channel );
         for ( int y = 0; y < m_height; ++y, ++buffer, v += m_width )
            P::FromSample( *buffer, *v );
      }
   }
 
   template <typename T>
   GenericImage& SetRow( const T* buffer, int y, int channel = -1 )
   {
      PCL_PRECONDITION( buffer != nullptr )
      if ( channel < 0 )
         channel = m_channel;
      if ( y >= 0 && y < m_height && channel >= 0 && channel < m_numberOfChannels )
         P::Copy( ScanLine( y, channel ), buffer, m_width );
      return *this;
   }
 
   template <typename T>
   GenericImage& SetColumn( const T* buffer, int x, int channel = -1 )
   {
      PCL_PRECONDITION( buffer != nullptr )
      if ( channel < 0 )
         channel = m_channel;
      if ( x >= 0 && x < m_width && channel >= 0 && channel < m_numberOfChannels )
      {
         sample* v = PixelAddress( x, 0, channel );
         for ( int y = 0; y < m_height; ++y, ++buffer, v += m_width )
            *v = P::ToSample( *buffer );
      }
      return *this;
   }
 
   // -------------------------------------------------------------------------
 
   GenericImage& CreateAlphaChannels( int n )
   {
      if ( n > 0 && m_numberOfChannels > 0 )
      {
         EnsureUnique();
         sample** oldData = m_pixelData;
         sample** newData = nullptr;
         try
         {
            newData = m_allocator.AllocateChannelSlots( m_numberOfChannels+n );
            for ( int i = 0; i < m_numberOfChannels; ++i )
               newData[i] = oldData[i];
            for ( int i = 0; i < n; ++i )
               newData[m_numberOfChannels+i] = m_allocator.AllocatePixels( m_width, m_height );
         }
         catch ( ... )
         {
            if ( newData != nullptr )
            {
               for ( int i = 0; i < n; ++i )
                  if ( newData[m_numberOfChannels+i] != nullptr )
                     m_allocator.Deallocate( newData[m_numberOfChannels+i] );
               m_allocator.Deallocate( newData );
            }
            throw;
         }
 
         m_allocator.SetSharedData( m_pixelData = newData );
         m_allocator.SetSharedGeometry( m_width, m_height, m_numberOfChannels += n );
         m_allocator.Deallocate( oldData );
      }
 
      return *this;
   }
 
   GenericImage& AddAlphaChannel( sample* data = nullptr )
   {
      // $$$ WARNING $$$
      // * If this is a shared image, data must either be null or point to a
      //   shared memory block.
      // * If this is a local image, data must either be null or point to a
      //   block allocated in the local heap.
 
      if ( data == nullptr )
         CreateAlphaChannels( 1 );
      else if ( m_numberOfChannels > 0 )
      {
         EnsureUnique();
         sample** oldData = m_pixelData;
         sample** newData = nullptr;
         try
         {
            newData = m_allocator.AllocateChannelSlots( m_numberOfChannels+1 );
            for ( int i = 0; i < m_numberOfChannels; ++i )
               newData[i] = oldData[i];
            newData[m_numberOfChannels] = data;
         }
         catch ( ... )
         {
            if ( newData != nullptr )
               m_allocator.Deallocate( newData );
            throw;
         }
 
         m_allocator.SetSharedData( m_pixelData = newData );
         m_allocator.SetSharedGeometry( m_width, m_height, ++m_numberOfChannels );
         m_allocator.Deallocate( oldData );
      }
 
      return *this;
   }
 
   GenericImage& ReleaseAlphaChannel( GenericImage& image, int channel )
   {
      if ( IsShared() != image.IsShared() )
         throw Error( "GenericImage::ReleaseAlphaChannel(): Cannot release pixel data between local and shared images" );
 
      if ( channel < 0 || channel >= NumberOfAlphaChannels() )
      {
         image.FreeData();
         return *this;
      }
 
      int c = NumberOfNominalChannels() + channel;
 
      sample** newData = nullptr;
      try
      {
         newData = image.m_allocator.AllocateChannelSlots( 1 );
         *newData = m_pixelData[c];
      }
      catch ( ... )
      {
         if ( newData != nullptr )
            image.m_allocator.Deallocate( newData );
         throw;
      }
 
      image.FreeData();
 
      image.m_pixelData = newData;
      image.m_width = m_width;
      image.m_height = m_height;
      image.m_numberOfChannels = 1;
      image.m_colorSpace = ColorSpace::Gray;
      image.m_data->UpdateSharedImage();
      image.ResetSelections();
 
      m_pixelData[c] = nullptr;
      ForgetAlphaChannel( channel );
 
      return *this;
   }
 
   GenericImage& DeleteAlphaChannel( int channel )
   {
      if ( channel >= 0 && channel < NumberOfAlphaChannels() )
      {
         EnsureUnique();
         int c = NumberOfNominalChannels() + channel;
         m_allocator.Deallocate( m_pixelData[c] );
         m_pixelData[c] = nullptr;
         ForgetAlphaChannel( channel );
      }
 
      return *this;
   }
 
   GenericImage& ForgetAlphaChannel( int channel )
   {
      if ( channel >= 0 && channel < NumberOfAlphaChannels() )
      {
         EnsureUnique();
         sample** oldData = m_pixelData;
         sample** newData = m_allocator.AllocateChannelSlots( m_numberOfChannels-1 );
 
         int n0 = NumberOfNominalChannels();
         int c = n0 + channel;
 
         for ( int i = 0; i < c; ++i )
            newData[i] = oldData[i];
         for ( int i = c, j = c; ++j < m_numberOfChannels; ++i )
            newData[i] = oldData[j];
 
         m_allocator.SetSharedData( m_pixelData = newData );
         m_allocator.SetSharedGeometry( m_width, m_height, --m_numberOfChannels );
 
         if ( m_channel >= n0 || m_lastChannel >= n0 )
            ResetChannelRange();
 
         m_allocator.Deallocate( oldData );
      }
 
      return *this;
   }
 
   GenericImage& DeleteAlphaChannels()
   {
      int n0 = NumberOfNominalChannels();
      int n = m_numberOfChannels;
      if ( n > n0 )
      {
         EnsureUnique();
         do
            m_allocator.Deallocate( m_pixelData[--n] ), m_pixelData[n] = nullptr;
         while ( n > n0 );
         ForgetAlphaChannels();
      }
 
      return *this;
   }
 
   GenericImage& ForgetAlphaChannels()
   {
      int n0 = NumberOfNominalChannels();
      if ( m_numberOfChannels > n0 )
      {
         EnsureUnique();
         sample** oldData = m_pixelData;
         sample** newData = m_allocator.AllocateChannelSlots( n0 );
 
         for ( int i = 0; i < n0; ++i )
            newData[i] = oldData[i];
 
         m_allocator.SetSharedData( m_pixelData = newData );
         m_allocator.SetSharedGeometry( m_width, m_height, m_numberOfChannels = n0 );
 
         if ( m_channel >= n0 || m_lastChannel >= n0 )
            ResetChannelRange();
 
         m_allocator.Deallocate( oldData );
      }
 
      return *this;
   }
 
   // -------------------------------------------------------------------------
 
   template <typename T>
   GenericImage& Fill( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Filling image", N*(1 + lastChannel - firstChannel) );
 
      sample v = P::ToSample( scalar );
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
            P::Fill( m_pixelData[i], v, N );
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width )
               P::Fill( f, v, w );
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage& Fill( const GenericVector<T>& values,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Filling image", N*(1 + lastChannel - firstChannel) );
 
      if ( r == Bounds() )
         for ( int i = firstChannel, c = 0; i <= lastChannel; ++i, ++c, m_status += N )
         {
            sample v = (c < values.Length()) ? P::ToSample( values[c] ) : P::MinSampleValue();
            P::Fill( m_pixelData[i], v, N );
         }
      else
         for ( int i = firstChannel, c = 0, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, ++c, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
            sample v = (c < values.Length()) ? P::ToSample( values[c] ) : P::MinSampleValue();
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width )
               P::Fill( f, v, w );
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage Filled( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Fill( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage Filled( const GenericVector<T>& values,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Fill( values );
      return result;
   }
 
   GenericImage& Zero( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Fill( P::ToSample( 0.0 ), rect, firstChannel, lastChannel );
   }
 
   GenericImage& One( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Fill( P::ToSample( 1.0 ), rect, firstChannel, lastChannel );
   }
 
   GenericImage& Black( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Fill( P::MinSampleValue(), rect, firstChannel, lastChannel );
   }
 
   GenericImage& White( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Fill( P::MaxSampleValue(), rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
   template <typename T>
   GenericImage& Invert( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Inverting pixel samples", N*(1 + lastChannel - firstChannel) );
 
      sample v = P::ToSample( scalar );
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            PCL_IVDEP
            for ( size_type j = 0; j < N; ++j, ++f )
               *f = v - *f;
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width-w )
            {
               PCL_IVDEP
               for ( int k = 0; k < w; ++k, ++f )
                  *f = v - *f;
            }
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage Inverted( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Invert( scalar );
      return result;
   }
 
   GenericImage& Invert( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Invert( P::MaxSampleValue(), rect, firstChannel, lastChannel );
   }
 
   GenericImage Inverted( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Invert();
      return result;
   }
 
   GenericImage operator ~() const
   {
      GenericImage result( *this );
      (void)result.Invert();
      return result;
   }
 
   GenericImage& Not( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Bitwise Not", N*(1 + lastChannel - firstChannel) );
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            PCL_IVDEP
            for ( size_type j = 0; j < N; ++j, ++f )
               P::Not( *f );
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width-w )
            {
               PCL_IVDEP
               for ( int k = 0; k < w; ++k, ++f )
                  P::Not( *f );
            }
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage& Truncate( T lowerBound, T upperBound,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Truncating pixel samples", N*(1 + lastChannel - firstChannel) );
 
      sample b0 = P::ToSample( lowerBound );
      sample b1 = P::ToSample( upperBound );
      if ( b1 < b0 )
         pcl::Swap( b0, b1 );
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            PCL_IVDEP
            for ( size_type j = 0; j < N; ++j, ++f )
               if ( *f < b0 )
                  *f = b0;
               else if ( b1 < *f )
                  *f = b1;
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width-w )
            {
               PCL_IVDEP
               for ( int k = 0; k < w; ++k, ++f )
                  if ( *f < b0 )
                     *f = b0;
                  else if ( b1 < *f )
                     *f = b1;
            }
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage Truncated( T lowerBound, T upperBound,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Truncate( lowerBound, upperBound );
      return result;
   }
 
   GenericImage& Truncate( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Truncate( P::MinSampleValue(), P::MaxSampleValue(), rect, firstChannel, lastChannel );
   }
 
   GenericImage Truncated( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Truncate();
      return result;
   }
 
   template <typename T>
   GenericImage& Rescale( T lowerBound, T upperBound,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      size_type N = r.IntegerArea();
      size_type Ns = N*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Rescaling pixel samples", Ns );
 
      sample b0 = P::ToSample( lowerBound );
      sample b1 = P::ToSample( upperBound );
      if ( b1 < b0 )
         pcl::Swap( b0, b1 );
 
      sample v0, v1;
      GetExtremePixelValues( v0, v1, r, firstChannel, lastChannel );
      if ( v0 == b0 && v1 == b1 )
      {
         m_status += Ns;
         return *this;
      }
 
      EnsureUnique();
 
      double d = 0;
      if ( b0 != b1 )
         if ( v0 != v1 )
            d = (double( b1 ) - double( b0 ))/(double( v1 ) - double( v0 ));
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
 
            if ( v0 != v1 )
            {
               if ( b0 != b1 )
               {
                  if ( b0 == sample( 0 ) )
                  {
                     PCL_IVDEP
                     for ( size_type j = 0; j < N; ++j, ++f )
                        *f = P::FloatToSample( d*(*f - v0) );
                  }
                  else
                  {
                     PCL_IVDEP
                     for ( size_type j = 0; j < N; ++j, ++f )
                        *f = P::FloatToSample( d*(*f - v0) + b0 );
                  }
               }
               else
                  P::Fill( f, b0, N );
            }
            else
               P::Fill( f, pcl::Range( v0, b0, b1 ), N );
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
 
            if ( v0 != v1 )
            {
               if ( b0 != b1 )
               {
                  if ( b0 == sample( 0 ) )
                  {
                     PCL_IVDEP
                     for ( int j = 0; j < h; ++j, f += m_width-w )
                     {
                        PCL_IVDEP
                        for ( int k = 0; k < w; ++k, ++f )
                           *f = P::FloatToSample( d*(*f - v0) );
                     }
                  }
                  else
                  {
                     PCL_IVDEP
                     for ( int j = 0; j < h; ++j, f += m_width-w )
                     {
                        PCL_IVDEP
                        for ( int k = 0; k < w; ++k, ++f )
                           *f = P::FloatToSample( d*(*f - v0) + b0 );
                     }
                  }
               }
               else
               {
                  PCL_IVDEP
                  for ( int j = 0; j < h; ++j, f += m_width )
                     P::Fill( f, b0, w );
               }
            }
            else
            {
               sample v = pcl::Range( v0, b0, b1 );
               PCL_IVDEP
               for ( int j = 0; j < h; ++j, f += m_width )
                  P::Fill( f, v, w );
            }
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage Rescaled( T lowerBound, T upperBound,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Rescale( lowerBound, upperBound );
      return result;
   }
 
   GenericImage& Rescale( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Rescale( P::MinSampleValue(), P::MaxSampleValue(), rect, firstChannel, lastChannel );
   }
 
   GenericImage Rescaled( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Rescale();
      return result;
   }
 
   template <typename T>
   GenericImage& Normalize( T lowerBound, T upperBound,
                            const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      size_type N = r.IntegerArea();
      size_type Ns = N*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Normalizing pixel samples", Ns );
 
      sample b0 = P::ToSample( lowerBound );
      sample b1 = P::ToSample( upperBound );
      if ( b1 < b0 )
         pcl::Swap( b0, b1 );
 
      sample v0, v1;
      GetExtremePixelValues( v0, v1, r, firstChannel, lastChannel );
 
      if ( v0 >= b0 && v1 <= b1 )
      {
         m_status += Ns;
         return *this;
      }
 
      EnsureUnique();
 
      double d = 0;
      if ( b0 != b1 )
         if ( v0 != v1 )
            d = (double( b1 ) - double( b0 ))/(double( v1 ) - double( v0 ));
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
 
            if ( v0 != v1 )
            {
               if ( b0 != b1 )
               {
                  if ( b0 == sample( 0 ) )
                  {
                     PCL_IVDEP
                     for ( size_type j = 0; j < N; ++j, ++f )
                        *f = P::FloatToSample( d*(*f - v0) );
                  }
                  else
                  {
                     PCL_IVDEP
                     for ( size_type j = 0; j < N; ++j, ++f )
                        *f = P::FloatToSample( d*(*f - v0) + b0 );
                  }
               }
               else
                  P::Fill( f, b0, N );
            }
            else
               P::Fill( f, pcl::Range( v0, b0, b1 ), N );
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
 
            if ( v0 != v1 )
            {
               if ( b0 != b1 )
               {
                  if ( b0 == sample( 0 ) )
                  {
                     PCL_IVDEP
                     for ( int j = 0; j < h; ++j, f += m_width-w )
                     {
                        PCL_IVDEP
                        for ( int k = 0; k < w; ++k, ++f )
                           *f = P::FloatToSample( d*(*f - v0) );
                     }
                  }
                  else
                  {
                     PCL_IVDEP
                     for ( int j = 0; j < h; ++j, f += m_width-w )
                     {
                        PCL_IVDEP
                        for ( int k = 0; k < w; ++k, ++f )
                           *f = P::FloatToSample( d*(*f - v0) + b0 );
                     }
                  }
               }
               else
               {
                  PCL_IVDEP
                  for ( int j = 0; j < h; ++j, f += m_width )
                     P::Fill( f, b0, w );
               }
            }
            else
            {
               sample v = pcl::Range( v0, b0, b1 );
               PCL_IVDEP
               for ( int j = 0; j < h; ++j, f += m_width )
                  P::Fill( f, v, w );
            }
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage Normalized( T lowerBound, T upperBound,
                            const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Normalize( lowerBound, upperBound );
      return result;
   }
 
   GenericImage& Normalize( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Normalize( P::MinSampleValue(), P::MaxSampleValue(), rect, firstChannel, lastChannel );
   }
 
   GenericImage Normalized( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Normalize();
      return result;
   }
 
   template <typename T>
   GenericImage& Binarize( T threshold,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Binarizing pixel samples", N*(1 + lastChannel - firstChannel) );
 
      sample t = P::ToSample( threshold );
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            PCL_IVDEP
            for ( size_type j = 0; j < N; ++j, ++f )
               *f = (*f < t) ? P::MinSampleValue() : P::MaxSampleValue();
         }
      else
         for ( int c = firstChannel, w = r.Width(), h = r.Height(); c <= lastChannel; ++c, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), c );
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width-w )
            {
               PCL_IVDEP
               for ( int k = 0; k < w; ++k, ++f )
                  *f = (*f < t) ? P::MinSampleValue() : P::MaxSampleValue();
            }
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage Binarized( T threshold,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Binarize( threshold );
      return result;
   }
 
   GenericImage& Binarize( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Binarize( (P::MinSampleValue() + P::MaxSampleValue())/2, rect, firstChannel, lastChannel );
   }
 
   GenericImage Binarized( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Binarize();
      return result;
   }
 
   GenericImage& SetAbsoluteValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing absolute value", N*(1 + lastChannel - firstChannel) );
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            PCL_IVDEP
            for ( size_type j = 0; j < N; ++j, ++f )
               *f = pcl::Abs( *f );
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
            PCL_IVDEP
            for ( int j = 0; j < h; ++j, f += m_width-w )
            {
               PCL_IVDEP
               for ( int k = 0; k < w; ++k, ++f )
                  *f = pcl::Abs( *f );
            }
         }
 
      return *this;
   }
 
   GenericImage& Abs( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetAbsoluteValue( rect, firstChannel, lastChannel );
   }
 
   GenericImage AbsoluteValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.SetAbsoluteValue();
      return result;
   }
 
   // -------------------------------------------------------------------------
 
   /*
    * Implementation of Apply( scalar ) member functions. We have to have a
    * separate implementation function to prevent infinite recursion in several
    * template specializations of the Apply() member function.
    */
   template <typename T>
   GenericImage& ApplyScalar( T scalar, image_op op = ImageOp::Mov,
                              const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( op == ImageOp::Div )
         if ( 1 + scalar == 1 )
            throw Error( "Division by zero or insignificant scalar" );
 
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Applying scalar: "
                              + ImageOp::Id( op )
                              + ' ' + String( scalar ), N*(1 + lastChannel - firstChannel) );
 
      if ( r == Bounds() )
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
#define ITERATE( Op )                                       \
            PCL_IVDEP                                       \
            for ( size_type j = 0; j < N; ++j, ++f )        \
               P::Op( *f, scalar )
            switch ( op )
            {
            case ImageOp::Mov:         ITERATE( Mov         ); break;
            case ImageOp::Add:         ITERATE( Add         ); break;
            case ImageOp::Sub:         ITERATE( Sub         ); break;
            case ImageOp::Mul:         ITERATE( Mul         ); break;
            case ImageOp::Div:         ITERATE( Div         ); break;
            case ImageOp::Pow:         ITERATE( Pow         ); break;
            case ImageOp::Dif:         ITERATE( Dif         ); break;
            case ImageOp::Min:         ITERATE( Min         ); break;
            case ImageOp::Max:         ITERATE( Max         ); break;
            case ImageOp::Not:         ITERATE( Not         ); break;
            case ImageOp::Or:          ITERATE( Or          ); break;
            case ImageOp::Nor:         ITERATE( Nor         ); break;
            case ImageOp::And:         ITERATE( And         ); break;
            case ImageOp::Nand:        ITERATE( Nand        ); break;
            case ImageOp::Xor:         ITERATE( Xor         ); break;
            case ImageOp::Xnor:        ITERATE( Xnor        ); break;
            case ImageOp::ColorBurn:   ITERATE( ColorBurn   ); break;
            case ImageOp::LinearBurn:  ITERATE( LinearBurn  ); break;
            case ImageOp::Screen:      ITERATE( Screen      ); break;
            case ImageOp::ColorDodge:  ITERATE( ColorDodge  ); break;
            case ImageOp::Overlay:     ITERATE( Overlay     ); break;
            case ImageOp::SoftLight:   ITERATE( SoftLight   ); break;
            case ImageOp::HardLight:   ITERATE( HardLight   ); break;
            case ImageOp::VividLight:  ITERATE( VividLight  ); break;
            case ImageOp::LinearLight: ITERATE( LinearLight ); break;
            case ImageOp::PinLight:    ITERATE( PinLight    ); break;
            case ImageOp::Exclusion:   ITERATE( Exclusion   ); break;
            default: break;
            }
#undef ITERATE
         }
      else
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( r.LeftTop(), i );
#define ITERATE( Op )                                       \
            PCL_IVDEP                                       \
            for ( int j = 0; j < h; ++j, f += m_width-w )   \
            {                                               \
               PCL_IVDEP                                    \
               for ( int k = 0; k < w; ++k, ++f )           \
                  P::Op( *f, scalar );                      \
            }
            switch ( op )
            {
            case ImageOp::Mov:         ITERATE( Mov         ); break;
            case ImageOp::Add:         ITERATE( Add         ); break;
            case ImageOp::Sub:         ITERATE( Sub         ); break;
            case ImageOp::Mul:         ITERATE( Mul         ); break;
            case ImageOp::Div:         ITERATE( Div         ); break;
            case ImageOp::Pow:         ITERATE( Pow         ); break;
            case ImageOp::Dif:         ITERATE( Dif         ); break;
            case ImageOp::Min:         ITERATE( Min         ); break;
            case ImageOp::Max:         ITERATE( Max         ); break;
            case ImageOp::Not:         ITERATE( Not         ); break;
            case ImageOp::Or:          ITERATE( Or          ); break;
            case ImageOp::Nor:         ITERATE( Nor         ); break;
            case ImageOp::And:         ITERATE( And         ); break;
            case ImageOp::Nand:        ITERATE( Nand        ); break;
            case ImageOp::Xor:         ITERATE( Xor         ); break;
            case ImageOp::Xnor:        ITERATE( Xnor        ); break;
            case ImageOp::ColorBurn:   ITERATE( ColorBurn   ); break;
            case ImageOp::LinearBurn:  ITERATE( LinearBurn  ); break;
            case ImageOp::Screen:      ITERATE( Screen      ); break;
            case ImageOp::ColorDodge:  ITERATE( ColorDodge  ); break;
            case ImageOp::Overlay:     ITERATE( Overlay     ); break;
            case ImageOp::SoftLight:   ITERATE( SoftLight   ); break;
            case ImageOp::HardLight:   ITERATE( HardLight   ); break;
            case ImageOp::VividLight:  ITERATE( VividLight  ); break;
            case ImageOp::LinearLight: ITERATE( LinearLight ); break;
            case ImageOp::PinLight:    ITERATE( PinLight    ); break;
            case ImageOp::Exclusion:   ITERATE( Exclusion   ); break;
            default: break;
            }
#undef ITERATE
         }
 
      return *this;
   }
 
   template <typename T>
   GenericImage& Apply( T scalar, image_op op = ImageOp::Mov,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return ApplyScalar( scalar, op, rect, firstChannel, lastChannel );
   }
 
   GenericImage& Apply( float scalar, image_op op = ImageOp::Mov,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( ImageOp::IsArithmeticOperator( op ) || ImageOp::IsPixelCompositionOperator( op ) )
         return ApplyScalar( scalar, op, rect, firstChannel, lastChannel );
      return ApplyScalar( P::ToSample( scalar ), op, rect, firstChannel, lastChannel );
   }
 
   GenericImage& Apply( double scalar, image_op op = ImageOp::Mov,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( ImageOp::IsArithmeticOperator( op ) || ImageOp::IsPixelCompositionOperator( op ) )
         return ApplyScalar( scalar, op, rect, firstChannel, lastChannel );
      return ApplyScalar( P::ToSample( scalar ), op, rect, firstChannel, lastChannel );
   }
 
   GenericImage& Apply( pcl::Complex<float> scalar, image_op op = ImageOp::Mov,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( ImageOp::IsArithmeticOperator( op ) || ImageOp::IsPixelCompositionOperator( op ) )
         return ApplyScalar( scalar, op, rect, firstChannel, lastChannel );
      return ApplyScalar( P::ToSample( scalar ), op, rect, firstChannel, lastChannel );
   }
 
   GenericImage& Apply( pcl::Complex<double> scalar, image_op op = ImageOp::Mov,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( ImageOp::IsArithmeticOperator( op ) || ImageOp::IsPixelCompositionOperator( op ) )
         return ApplyScalar( scalar, op, rect, firstChannel, lastChannel );
      return ApplyScalar( P::ToSample( scalar ), op, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage Applied( T scalar, image_op op = ImageOp::Mov,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Apply( scalar, op );
      return result;
   }
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   GenericImage& Apply( const GenericImage<P1>& image, image_op op = ImageOp::Mov,
                        const Point& point = Point( int_max ), int channel = -1,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !image.ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      if ( !ParseChannel( channel ) )
         return *this;
 
      Point p = point;
      if ( p.x == int_max || p.y == int_max )
         p = m_point;
 
      if ( p.x < 0 )
      {
         if ( (r.x0 -= p.x) >= r.x1 )
            return *this;
         p.x = 0;
      }
      else if ( p.x >= m_width )
         return *this;
 
      if ( p.y < 0 )
      {
         if ( (r.y0 -= p.y) >= r.y1 )
            return *this;
         p.y = 0;
      }
      else if ( p.y >= m_height )
         return *this;
 
      r.ResizeTo( pcl::Min( m_width - p.x, r.Width() ),
                  pcl::Min( m_height - p.y, r.Height() ) );
 
      lastChannel = pcl::Min( lastChannel, firstChannel + m_numberOfChannels - channel - 1 );
 
      EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Applying image, op=" + ImageOp::Id( op ), N*(1 + lastChannel - firstChannel) );
 
      if ( r == Bounds() && r == image.Bounds() )
         for ( int i = channel, j = firstChannel; j <= lastChannel; ++i, ++j, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            const typename P1::sample* __restrict__ g = image[j];
 
#define ITERATE( Op )                                          \
            PCL_IVDEP                                          \
            for ( size_type k = 0; k < N; ++k, ++f, ++g )      \
               P::Op( *f, *g )
            switch ( op )
            {
            case ImageOp::Mov:
               P::Copy( f, g, N );
               break;
            case ImageOp::Min:
               P::CopyMin( f, g, N );
               break;
            case ImageOp::Max:
               P::CopyMax( f, g, N );
               break;
            default:
               switch ( op )
               {
               case ImageOp::Add:         ITERATE( Add         ); break;
               case ImageOp::Sub:         ITERATE( Sub         ); break;
               case ImageOp::Mul:         ITERATE( Mul         ); break;
               case ImageOp::Div:
                  for ( size_type j = 0; j < N; ++j, ++f, ++g )
                     if ( *g != 0 )
                        P::Div( *f, *g );
                     else
                        *f = P::MaxSampleValue();
                  break;
               case ImageOp::Pow:         ITERATE( Pow         ); break;
               case ImageOp::Dif:         ITERATE( Dif         ); break;
               case ImageOp::Not:         ITERATE( Not         ); break;
               case ImageOp::Or:          ITERATE( Or          ); break;
               case ImageOp::Nor:         ITERATE( Nor         ); break;
               case ImageOp::And:         ITERATE( And         ); break;
               case ImageOp::Nand:        ITERATE( Nand        ); break;
               case ImageOp::Xor:         ITERATE( Xor         ); break;
               case ImageOp::Xnor:        ITERATE( Xnor        ); break;
               case ImageOp::ColorBurn:   ITERATE( ColorBurn   ); break;
               case ImageOp::LinearBurn:  ITERATE( LinearBurn  ); break;
               case ImageOp::Screen:      ITERATE( Screen      ); break;
               case ImageOp::ColorDodge:  ITERATE( ColorDodge  ); break;
               case ImageOp::Overlay:     ITERATE( Overlay     ); break;
               case ImageOp::SoftLight:   ITERATE( SoftLight   ); break;
               case ImageOp::HardLight:   ITERATE( HardLight   ); break;
               case ImageOp::VividLight:  ITERATE( VividLight  ); break;
               case ImageOp::LinearLight: ITERATE( LinearLight ); break;
               case ImageOp::PinLight:    ITERATE( PinLight    ); break;
               case ImageOp::Exclusion:   ITERATE( Exclusion   ); break;
               default: break;
               }
#undef ITERATE
               break;
            }
         }
      else
         for ( int i = channel, j = firstChannel, w = r.Width(), h = r.Height(); j <= lastChannel; ++i, ++j, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( p, i );
            const typename P1::sample* __restrict__ g = image.PixelAddress( r.LeftTop(), j );
 
#define ITERATE( Op )                                                            \
            PCL_IVDEP                                                            \
            for ( int k = 0; k < h; ++k, f += m_width-w, g += image.Width()-w )  \
            {                                                                    \
               PCL_IVDEP                                                         \
               for ( int l = 0; l < w; ++l, ++f, ++g )                           \
                  P::Op( *f, *g );                                               \
            }
            switch ( op )
            {
            case ImageOp::Mov:
               for ( int k = 0; k < h; ++k, f += m_width, g += image.Width() )
                  P::Copy( f, g, w );
               break;
            case ImageOp::Min:
               for ( int k = 0; k < h; ++k, f += m_width, g += image.Width() )
                  P::CopyMin( f, g, w );
               break;
            case ImageOp::Max:
               for ( int k = 0; k < h; ++k, f += m_width, g += image.Width() )
                  P::CopyMax( f, g, w );
               break;
            case ImageOp::Add:         ITERATE( Add         ); break;
            case ImageOp::Sub:         ITERATE( Sub         ); break;
            case ImageOp::Mul:         ITERATE( Mul         ); break;
            case ImageOp::Div:
               PCL_IVDEP
               for ( int k = 0; k < h; ++k, f += m_width-w, g += image.Width()-w )
               {
                  PCL_IVDEP
                  for ( int l = 0; l < w; ++l, ++f, ++g )
                     if ( *g != 0 )
                        P::Div( *f, *g );
                     else
                        *f = P::MaxSampleValue();
               }
               break;
            case ImageOp::Pow:         ITERATE( Pow         ); break;
            case ImageOp::Dif:         ITERATE( Dif         ); break;
            case ImageOp::Not:         ITERATE( Not         ); break;
            case ImageOp::Or:          ITERATE( Or          ); break;
            case ImageOp::Nor:         ITERATE( Nor         ); break;
            case ImageOp::And:         ITERATE( And         ); break;
            case ImageOp::Nand:        ITERATE( Nand        ); break;
            case ImageOp::Xor:         ITERATE( Xor         ); break;
            case ImageOp::Xnor:        ITERATE( Xnor        ); break;
            case ImageOp::ColorBurn:   ITERATE( ColorBurn   ); break;
            case ImageOp::LinearBurn:  ITERATE( LinearBurn  ); break;
            case ImageOp::Screen:      ITERATE( Screen      ); break;
            case ImageOp::ColorDodge:  ITERATE( ColorDodge  ); break;
            case ImageOp::Overlay:     ITERATE( Overlay     ); break;
            case ImageOp::SoftLight:   ITERATE( SoftLight   ); break;
            case ImageOp::HardLight:   ITERATE( HardLight   ); break;
            case ImageOp::VividLight:  ITERATE( VividLight  ); break;
            case ImageOp::LinearLight: ITERATE( LinearLight ); break;
            case ImageOp::PinLight:    ITERATE( PinLight    ); break;
            case ImageOp::Exclusion:   ITERATE( Exclusion   ); break;
               break;
            default:
               break;
            }
#undef ITERATE
         }
 
      return *this;
   }
 
   template <class P1>
   GenericImage Applied( const GenericImage<P1>& image, image_op op = ImageOp::Mov,
                         const Point& point = Point( int_max ), int channel = -1,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      int c0 = (channel < 0) ? m_channel : channel;
      int c1 = c0 + ((firstChannel < 0) ? image.FirstSelectedChannel() : firstChannel);
      int c2 = c0 + ((lastChannel < 0) ? image.LastSelectedChannel() : lastChannel);
      GenericImage result( *this, rect.MovedTo( point ), c1, c2 );
      (void)result.Apply( image, op, Point( 0 ), 0, rect, firstChannel, lastChannel );
      return result;
   }
 
   // -------------------------------------------------------------------------
 
   GenericImage& Apply( const ImageTransformation& transformation,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 );
   // ### Implemented in pcl/ImageTransformation.h (because of mutual dependencies)
 
   GenericImage Applied( const ImageTransformation& transformation,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Apply( transformation );
      return result;
   }
 
   void Transform( BidirectionalImageTransformation& transform,
                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const;
   // ### Implemented in pcl/ImageTransformation.h (because of mutual dependencies)
 
   // -------------------------------------------------------------------------
 
#ifndef __PCL_IMAGE_NO_BITMAP
 
   GenericImage& Blend( const Bitmap& bitmap,
                        const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ) )
   {
      Rect r = rect;
      if ( r.IsRect() )
         r = bitmap.Bounds().Intersection( r );
      else
         r = bitmap.Bounds();
      if ( !r.IsRect() )
         return *this;
 
      Point p = point;
      if ( p.x == int_max || p.y == int_max )
         p = m_point;
 
      if ( p.x < 0 )
      {
         if ( (r.x0 -= p.x) >= r.x1 )
            return *this;
         p.x = 0;
      }
      else if ( p.x >= m_width )
         return *this;
 
      if ( p.y < 0 )
      {
         if ( (r.y0 -= p.y) >= r.y1 )
            return *this;
         p.y = 0;
      }
      else if ( p.y >= m_height )
         return *this;
 
      r.ResizeTo( pcl::Min( m_width - p.x, r.Width() ),
                  pcl::Min( m_height - p.y, r.Height() ) );
 
      bool hasAlpha = HasAlphaChannels();
      int w = r.Width();
      int h = r.Height();
 
      EnsureUnique();
 
      if ( IsColor() )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Blending RGBA bitmap", size_type( w )*size_type( h ) );
 
         sample* __restrict__ fR = nullptr;
         sample* __restrict__ fG = nullptr;
         sample* __restrict__ fB = nullptr;
         sample* __restrict__ fA = nullptr;
 
         for ( int i = 0; i < h; ++i, ++p.y, m_status += w )
         {
            fR = PixelAddress( p, 0 );
            fG = PixelAddress( p, 1 );
            fB = PixelAddress( p, 2 );
            if ( hasAlpha )
               fA = PixelAddress( p, 3 );
 
            const RGBA* __restrict__ g = bitmap.ScanLine( r.y0 + i ) + r.x0;
 
            for ( int j = 0; j < w; ++j, ++fR, ++fG, ++fB, ++fA, ++g )
            {
               RGBA rgba = *g;
 
               uint8 A = Alpha( rgba );
 
               if ( hasAlpha )
               {
                  P::Mov( *fR, Red( rgba ) );
                  P::Mov( *fG, Green( rgba ) );
                  P::Mov( *fB, Blue( rgba ) );
                  P::Mov( *fA, A );
               }
               else if ( A != 0 )
               {
                  if ( A == 0xFF )
                  {
                     P::Mov( *fR, Red( rgba ) );
                     P::Mov( *fG, Green( rgba ) );
                     P::Mov( *fB, Blue( rgba ) );
                  }
                  else
                  {
                     double k = PTLUT->pDLUTA[A];
                     double k1 = PTLUT->p1DLUT8[A];
                     double v;
                     P::FromSample( v, *fR ), P::Mov( *fR, k*Red( rgba )   + k1*v );
                     P::FromSample( v, *fG ), P::Mov( *fG, k*Green( rgba ) + k1*v );
                     P::FromSample( v, *fB ), P::Mov( *fB, k*Blue( rgba )  + k1*v );
                  }
               }
            }
         }
      }
      else
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Blending grayscale bitmap", size_type( w )*size_type( h ) );
 
         sample* __restrict__ fK = nullptr;
         sample* __restrict__ fA = nullptr;
 
         for ( int i = 0; i < h; ++i, ++p.y, m_status += w )
         {
            fK = PixelAddress( p, 0 );
            if ( hasAlpha )
               fA = PixelAddress( p, 1 );
 
            const RGBA* __restrict__ g = bitmap.ScanLine( r.y0 + i ) + r.x0;
 
            for ( int j = 0; j < w; ++j, ++fK, ++fA, ++g )
            {
               RGBA rgba = *g;
               uint8 R = Red( rgba );
               uint8 G = Green( rgba );
               uint8 B = Blue( rgba );
               uint8 A = Alpha( rgba );
 
               double K = 0.5*(pcl::Min( pcl::Min( R, G ), B )
                             + pcl::Max( pcl::Max( R, G ), B ));
 
               if ( hasAlpha )
               {
                  P::Mov( *fK, K/255 );
                  P::Mov( *fA, A );
               }
               else if ( A != 0 )
               {
                  if ( A == 0xFF )
                     P::Mov( *fK, K/255 );
                  else
                  {
                     double v;
                     P::FromSample( v, *fK );
                     P::Mov( *fK, PTLUT->pDLUTA[A]*K + PTLUT->p1DLUT8[A]*v );
                  }
               }
            }
         }
      }
 
      return *this;
   }
 
   GenericImage Blended( const Bitmap& bitmap,
                         const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ) ) const
   {
      GenericImage result( *this, Bounds(), 0, m_numberOfChannels-1 );
      (void)result.Blend( bitmap, point, rect );
      return result;
   }
 
#endif   // !__PCL_IMAGE_NO_BITMAP
 
   // -------------------------------------------------------------------------
 
   template <typename T>
   GenericImage& Move( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Mov, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Mov( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Move( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Add( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Add, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& operator +=( T scalar )
   {
      return Add( scalar );
   }
 
   template <typename T>
   GenericImage Added( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Add( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& Subtract( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Sub, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Sub( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Subtract( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& operator -=( T scalar )
   {
      return Subtract( scalar );
   }
 
   template <typename T>
   GenericImage Subtracted( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Subtract( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& Multiply( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Mul, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Mul( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Multiply( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& operator *=( T scalar )
   {
      return Multiply( scalar );
   }
 
   template <typename T>
   GenericImage Multiplied( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Multiply( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& Divide( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Div, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Div( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Divide( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& operator /=( T scalar )
   {
      return Divide( scalar );
   }
 
   template <typename T>
   GenericImage Divided( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Divide( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& Raise( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Pow, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Pow( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Raise( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& operator ^=( T scalar )
   {
      return Raise( scalar );
   }
 
   template <typename T>
   GenericImage Raised( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.Raise( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& SetAbsoluteDifference( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Dif, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Dif( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetAbsoluteDifference( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage AbsoluteDifference( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.SetAbsoluteDifference( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& SetMinimum( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Min, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Min( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetMinimum( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage Minimum( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.SetMinimum( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& SetMaximum( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Max, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Max( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetMaximum( scalar, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage Maximum( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      GenericImage result( *this, rect, firstChannel, lastChannel );
      (void)result.SetMaximum( scalar );
      return result;
   }
 
   template <typename T>
   GenericImage& Or( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Or, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& And( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::And, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Xor( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Xor, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Nor( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Nor, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Nand( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Nand, rect, firstChannel, lastChannel );
   }
 
   template <typename T>
   GenericImage& Xnor( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( scalar, ImageOp::Xnor, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   GenericImage& Move( const GenericImage<P1>& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Mov, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Mov( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Move( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Add( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Add, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& operator +=( const GenericImage<P1>& image )
   {
      return Add( image );
   }
 
   template <class P1>
   GenericImage& Subtract( const GenericImage<P1>& image,
                           const Point& point = Point( int_max ), int channel = -1,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Sub, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Sub( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Subtract( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& operator -=( const GenericImage<P1>& image )
   {
      return Subtract( image );
   }
 
   template <class P1>
   GenericImage& Multiply( const GenericImage<P1>& image,
                           const Point& point = Point( int_max ), int channel = -1,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Mul, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Mul( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Multiply( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& operator *=( const GenericImage<P1>& image )
   {
      return Multiply( image );
   }
 
   template <class P1>
   GenericImage& Divide( const GenericImage<P1>& image,
                         const Point& point = Point( int_max ), int channel = -1,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Div, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Div( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Divide( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& operator /=( const GenericImage<P1>& image )
   {
      return Divide( image );
   }
 
   template <class P1>
   GenericImage& Raise( const GenericImage<P1>& image,
                        const Point& point = Point( int_max ), int channel = -1,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Pow, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Pow( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Raise( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& operator ^=( const GenericImage<P1>& image )
   {
      return Raise( image );
   }
 
   template <class P1>
   GenericImage& SetAbsoluteDifference( const GenericImage<P1>& image,
                                        const Point& point = Point( int_max ), int channel = -1,
                                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Dif, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Dif( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetAbsoluteDifference( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& SetMinimum( const GenericImage<P1>& image,
                             const Point& point = Point( int_max ), int channel = -1,
                             const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Min, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Min( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetMinimum( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& SetMaximum( const GenericImage<P1>& image,
                             const Point& point = Point( int_max ), int channel = -1,
                             const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Max, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Max( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetMaximum( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Or( const GenericImage<P1>& image,
                     const Point& point = Point( int_max ), int channel = -1,
                     const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Or, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& And( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::And, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Xor( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Xor, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Nor( const GenericImage<P1>& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Nor, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Nand( const GenericImage<P1>& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Nand, point, channel, rect, firstChannel, lastChannel );
   }
 
   template <class P1>
   GenericImage& Xnor( const GenericImage<P1>& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Apply( image, ImageOp::Xnor, point, channel, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   GenericImage& Exchange( GenericImage<P1>& image,
                           const Point& point = Point( int_max ), int channel = -1,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      Rect r = rect;
      if ( !image.ParseSelection( r, firstChannel, lastChannel ) )
         return *this;
 
      if ( !ParseChannel( channel ) )
         return *this;
 
      Point p = point;
      if ( p.x == int_max || p.y == int_max )
         p = m_point;
 
      if ( p.x < 0 )
      {
         if ( (r.x0 -= p.x) >= r.x1 )
            return *this;
         p.x = 0;
      }
      else if ( p.x >= m_width )
         return *this;
 
      if ( p.y < 0 )
      {
         if ( (r.y0 -= p.y) >= r.y1 )
            return *this;
         p.y = 0;
      }
      else if ( p.y >= m_height )
         return *this;
 
      r.ResizeTo( pcl::Min( m_width - p.x, r.Width() ),
                  pcl::Min( m_height - p.y, r.Height() ) );
 
      lastChannel = pcl::Min( lastChannel, firstChannel + m_numberOfChannels - channel - 1 );
 
      EnsureUnique();
      image.EnsureUnique();
 
      size_type N = r.IntegerArea();
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Exchanging pixel samples", N*(1 + lastChannel - firstChannel) );
 
      if ( r == Bounds() && r == image.Bounds() )
         for ( int i = channel, j = firstChannel; j <= lastChannel; ++i, ++j, m_status += N )
         {
            sample* __restrict__ f = m_pixelData[i];
            typename P1::sample* __restrict__ g = image[j];
            PCL_IVDEP
            for ( size_type k = 0; k < N; ++k, ++f, ++g )
            {
               sample t = *f;
               P1::FromSample( *f, *g );
               P::FromSample( *g, t );
            }
         }
      else
         for ( int i = channel, j = firstChannel, w = r.Width(), h = r.Height(); j <= lastChannel; ++i, ++j, m_status += N )
         {
            sample* __restrict__ f = PixelAddress( p, i );
            typename P1::sample* __restrict__ g = image.PixelAddress( r.LeftTop(), j );
            PCL_IVDEP
            for ( int k = 0; k < h; ++k, f += m_width-w, g += image.Width()-w )
            {
               PCL_IVDEP
               for ( int l = 0; l < w; ++l, ++f, ++g )
               {
                  sample t = *f;
                  P1::FromSample( *f, *g );
                  P::FromSample( *g, t );
               }
            }
         }
 
      return *this;
   }
 
   template <class P1>
   GenericImage& Xchg( GenericImage<P1>& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Exchange( image, point, channel, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
   Array<double> PixelSamples( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                               int maxProcessors = 0, bool __performanceAnalysis__ = false )
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return Array<double>();
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Sampling pixel values", N );
 
      Array<size_type> L;
      if ( likely( !__performanceAnalysis__ ) )
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sampling;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      else
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, 1/*overheadLimitPx*/ );
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<DSmpThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new DSmpThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( DSmpThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( DSmpThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      Array<double> values;
      for ( DSmpThread& thread : threads )
         if ( thread.n > 0 )
         {
            values.Add( thread.values.Begin(), thread.values.At( thread.n ) );
            thread.values.Clear();
         }
 
      threads.Destroy();
      m_status += N;
      return values;
   }
 
   // -------------------------------------------------------------------------
 
   sample MinimumSampleValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                              int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing minimum pixel sample value", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<MinThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new MinThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( MinThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( MinThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      sample min = P::MinSampleValue();
      for ( size_type i = 0; i < threads.Length(); ++i )
         if ( threads[i].count > 0 )
         {
            min = threads[i].min;
            while ( ++i < threads.Length() )
               if ( threads[i].count > 0 )
                  if ( threads[i].min < min )
                     min = threads[i].min;
            break;
         }
 
      threads.Destroy();
      m_status += N;
      return min;
   }
 
   sample MinimumPixelValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                             int maxProcessors = 0 ) const
   {
      return MinimumSampleValue( rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample MaximumSampleValue( const Rect& rect = Rect( 0 ),
                              int firstChannel = -1, int lastChannel = -1, int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing maximum pixel sample value", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<MaxThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new MaxThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( MaxThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( MaxThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      sample max = P::MinSampleValue();
      for ( size_type i = 0; i < threads.Length(); ++i )
         if ( threads[i].count > 0 )
         {
            max = threads[i].max;
            while ( ++i < threads.Length() )
               if ( threads[i].count > 0 )
                  if ( max < threads[i].max )
                     max = threads[i].max;
            break;
         }
 
      threads.Destroy();
      m_status += N;
      return max;
   }
 
   sample MaximumPixelValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                             int maxProcessors = 0 ) const
   {
      return MaximumSampleValue( rect, firstChannel, lastChannel, maxProcessors );
   }
 
   template <typename T>
   void GetExtremeSampleValues( T& min, T& max,
                                const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                int maxProcessors = 0, bool __performanceAnalysis__ = false ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
      {
         // ### Required for compatibility with PCL 1.x
         P::FromSample( min, P::MinSampleValue() );
         max = min;
         return;
      }
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing extreme pixel sample values", N );
 
      Array<size_type> L;
      if ( likely( !__performanceAnalysis__ ) )
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      else
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, 1/*overheadLimitPx*/ );
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<MinMaxThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new MinMaxThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( MinMaxThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( MinMaxThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      sample vmin = P::MinSampleValue();
      sample vmax = P::MinSampleValue();
      for ( size_type i = 0; i < threads.Length(); ++i )
         if ( threads[i].count > 0 )
         {
            vmin = threads[i].min;
            vmax = threads[i].max;
            while ( ++i < threads.Length() )
               if ( threads[i].count > 0 )
               {
                  if ( threads[i].min < vmin )
                     vmin = threads[i].min;
                  if ( vmax < threads[i].max )
                     vmax = threads[i].max;
               }
            break;
         }
 
      threads.Destroy();
      m_status += N;
      P::FromSample( min, vmin );
      P::FromSample( max, vmax );
   }
 
   void GetExtremePixelValues( sample& min, sample& max,
                               const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                               int maxProcessors = 0 ) const
   {
      GetExtremeSampleValues( min, max, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample LocateMinimumSampleValue( int& xmin, int& ymin,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
      {
         // ### Required for compatibility with PCL 1.x
         xmin = ymin = 0;
         return P::MinSampleValue();
      }
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Locating minimum pixel sample value", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<MinPosThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new MinPosThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( MinPosThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( MinPosThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      xmin = ymin = -1;
      sample min = P::MinSampleValue();
      for ( size_type i = 0; i < threads.Length(); ++i )
         if ( threads[i].count > 0 )
         {
            min = threads[i].min;
            xmin = threads[i].pmin.x;
            ymin = threads[i].pmin.y;
            while ( ++i < threads.Length() )
               if ( threads[i].count > 0 )
                  if ( threads[i].min < min )
                  {
                     min = threads[i].min;
                     xmin = threads[i].pmin.x;
                     ymin = threads[i].pmin.y;
                  }
            break;
         }
 
      threads.Destroy();
      m_status += N;
      return min;
   }
 
   sample LocateMinimumSampleValue( Point& pmin,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      return LocateMinimumSampleValue( pmin.x, pmin.y, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample LocateMinimumPixelValue( int& xmin, int& ymin,
                                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                   int maxProcessors = 0 ) const
   {
      return LocateMinimumSampleValue( xmin, ymin, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample LocateMinimumPixelValue( Point& pmin,
                                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                   int maxProcessors = 0 ) const
   {
      return LocateMinimumSampleValue( pmin, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample LocateMaximumSampleValue( int& xmax, int& ymax,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
      {
         // ### Required for compatibility with PCL 1.x
         xmax = ymax = 0;
         return P::MaxSampleValue();
      }
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Locating maximum pixel sample value", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<MaxPosThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new MaxPosThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( MaxPosThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( MaxPosThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      xmax = ymax = -1;
      sample max = P::MinSampleValue();
      for ( size_type i = 0; i < threads.Length(); ++i )
         if ( threads[i].count > 0 )
         {
            max = threads[i].max;
            xmax = threads[i].pmax.x;
            ymax = threads[i].pmax.y;
            while ( ++i < threads.Length() )
               if ( threads[i].count > 0 )
                  if ( max < threads[i].max )
                  {
                     max = threads[i].max;
                     xmax = threads[i].pmax.x;
                     ymax = threads[i].pmax.y;
                  }
            break;
         }
 
      threads.Destroy();
      m_status += N;
      return max;
   }
 
   sample LocateMaximumSampleValue( Point& pmax,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      return LocateMaximumSampleValue( pmax.x, pmax.y, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample LocateMaximumPixelValue( int& xmax, int& ymax,
                                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                   int maxProcessors = 0 ) const
   {
      return LocateMaximumSampleValue( xmax, ymax, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   sample LocateMaximumPixelValue( Point& pmax,
                                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                   int maxProcessors = 0 ) const
   {
      return LocateMaximumSampleValue( pmax, rect, firstChannel, lastChannel, maxProcessors );
   }
 
   template <typename T>
   void LocateExtremeSampleValues( int& xmin, int& ymin, T& min,
                                   int& xmax, int& ymax, T& max,
                                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                   int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
      {
         // ### Required for compatibility with PCL 1.x
         xmin = ymin = xmax = ymax = 0;
         P::FromSample( min, P::MinSampleValue() );
         max = min;
         return;
      }
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Locating extreme pixel sample values", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<MinMaxPosThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new MinMaxPosThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( MinMaxPosThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( MinMaxPosThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      xmin = ymin = xmax = ymax = -1;
      sample vmin = P::MinSampleValue();
      sample vmax = P::MinSampleValue();
      for ( size_type i = 0; i < threads.Length(); ++i )
         if ( threads[i].count > 0 )
         {
            vmin = threads[i].min;
            xmin = threads[i].pmin.x;
            ymin = threads[i].pmin.y;
            vmax = threads[i].max;
            xmax = threads[i].pmax.x;
            ymax = threads[i].pmax.y;
            while ( ++i < threads.Length() )
               if ( threads[i].count > 0 )
               {
                  if ( threads[i].min < vmin )
                  {
                     vmin = threads[i].min;
                     xmin = threads[i].pmin.x;
                     ymin = threads[i].pmin.y;
                  }
                  if ( vmax < threads[i].max )
                  {
                     vmax = threads[i].max;
                     xmax = threads[i].pmax.x;
                     ymax = threads[i].pmax.y;
                  }
               }
            break;
         }
 
      threads.Destroy();
      m_status += N;
      P::FromSample( min, vmin );
      P::FromSample( max, vmax );
   }
 
   template <typename T>
   void LocateExtremeSampleValues( Point& pmin, T& min,
                                   Point& pmax, T& max,
                                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                   int maxProcessors = 0 ) const
   {
      LocateExtremeSampleValues( pmin.x, pmin.y, min,
                                 pmax.x, pmax.y, max,
                                 rect, firstChannel, lastChannel, maxProcessors );
   }
 
   size_type Count( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                    int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Counting pixel samples", N );
 
      if ( !this->IsRangeClippingEnabled() )
      {
         m_status += N;
         return size_type( r.Width() ) * size_type( r.Height() ) * size_type( 1 + lastChannel - firstChannel );
      }
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<CountThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new CountThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( CountThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( CountThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      size_type count = 0;
      for ( const CountThread& thread : threads )
         count += thread.count;
 
      threads.Destroy();
      m_status += N;
      return count;
   }
 
   double Mean( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                int maxProcessors = 0, bool __performanceAnalysis__ = false ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing mean pixel sample value", N );
 
      Array<size_type> L;
      if ( likely( !__performanceAnalysis__ ) )
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      else
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, 1/*overheadLimitPx*/ );
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new SumThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( SumThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s = 0;
      double e = 0;
      size_type n = 0;
      for ( const SumThread& thread : threads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
         n += thread.n;
      }
 
      threads.Destroy();
 
      m_status += N;
 
      if ( n == 0 )
         return 0;
      return s/n;
   }
 
   double Median( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                  int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing median pixel sample value", N );
 
      if ( N <= 4096 )
      {
         SmpThread S( *this, r, firstChannel, lastChannel, 0, r.Height() );
         S.Run();
         if ( S.n == 0 )
         {
            m_status += N;
            return 0;
         }
         double m = double( *pcl::Select( S.samples.Begin(), S.samples.At( S.n ), S.n >> 1 ) )/double( P::MaxSampleValue() );
         if ( S.n & 1 )
         {
            m_status += N;
            return m;
         }
         m = (m + double( *pcl::Select( S.samples.Begin(), S.samples.At( S.n ), (S.n >> 1)-1 ) )/double( P::MaxSampleValue() ))/2;
         m_status += N;
         return m;
      }
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
 
      double low, high;
      size_type count = 0;
      {
         Array<size_type> L;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ReferenceArray<MinMaxThread> threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads << new MinMaxThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) );
 
         if ( threads.Length() > 1 )
         {
            int i = 0;
            for ( MinMaxThread& thread : threads )
               thread.Start( ThreadPriority::DefaultMax, useAffinity ? i++ : -1 );
            for ( MinMaxThread& thread : threads )
               thread.Wait();
         }
         else
            threads[0].Run();
 
         sample slow = 0, shigh = 0;
         for ( size_type i = 0; i < threads.Length(); ++i )
            if ( threads[i].count > 0 )
            {
               slow = threads[i].min;
               shigh = threads[i].max;
               count = threads[i].count;
               while ( ++i < threads.Length() )
                  if ( threads[i].count > 0 )
                  {
                     if ( threads[i].min < slow )
                        slow = threads[i].min;
                     if ( shigh < threads[i].max )
                        shigh = threads[i].max;
                     count += threads[i].count;
                  }
               break;
            }
 
         threads.Destroy();
 
         low = double( slow );
         high = double( shigh );
      }
 
      if ( count == 0 )
      {
         m_status += N;
         return 0;
      }
 
      const double eps = P::IsComplexSample() ? 2*std::numeric_limits<double>::epsilon() :
                           (P::IsFloatSample() ? 2*std::numeric_limits<typename P::component>::epsilon() :
                              0.5/Pow2( double( P::BitsPerSample() ) ));
      if ( high - low < eps )
      {
         m_status += N;
         return low/double( P::MaxSampleValue() );
      }
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::FastMedian;
         data.length = N;
         data.overheadLimit = __PCL_MEDIAN_HISTOGRAM_OVERHEAD;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      ReferenceArray<HistogramThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads << new HistogramThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ), low, high );
 
      double mh = 0, l0 = low;
      SzVector H0;
 
      for ( size_type n = 0, n2 = count >> 1, step = 0, it = 0;; ++it )
      {
         SzVector H;
         if ( it == 0 && step )
            H = H0;
         else
         {
            if ( threads.Length() > 1 )
            {
               int i = 0;
               for ( HistogramThread& thread : threads )
                  thread.Start( ThreadPriority::DefaultMax, useAffinity ? i++ : -1 );
               for ( HistogramThread& thread : threads )
                  thread.Wait();
            }
            else
               threads[0].Run();
 
            H = threads[0].H;
            for ( size_type i = 1; i < threads.Length(); ++i )
               H += threads[i].H;
            if ( it == 0 )
               if ( (count & 1) == 0 )
                  H0 = H;
         }
 
         for ( int i = 0; ; n += H[i++] )
            if ( n + H[i] > n2 )
            {
               double range = high - low;
               high = (range * (i + 1))/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + low;
               low = (range * i)/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + low;
               if ( high - low < eps )
               {
                  if ( count & 1 )
                  {
                     threads.Destroy();
                     m_status += N;
                     return low/double( P::MaxSampleValue() );
                  }
                  if ( step )
                  {
                     threads.Destroy();
                     m_status += N;
                     return (low + mh)/2/double( P::MaxSampleValue() );
                  }
                  mh = low;
                  low = l0;
                  n = 0;
                  --n2;
                  ++step;
                  it = 0;
               }
               break;
            }
      }
   }
 
   double OrderStatistic( double k,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                          int maxProcessors = 0 ) const
   {
      if ( k < 0 || k > 1 )
         return 0;
 
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing order statistic", N );
 
      if ( N <= 4096 )
      {
         SmpThread S( *this, r, firstChannel, lastChannel, 0, r.Height() );
         S.Run();
         m_status += N;
         if ( S.n == 0 )
            return 0;
         return double( *pcl::Select( S.samples.Begin(), S.samples.At( S.n ), distance_type( k*(S.n - 1) ) ) )/double( P::MaxSampleValue() );
      }
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
 
      double low, high;
      size_type count = 0;
      {
         Array<size_type> L;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ReferenceArray<MinMaxThread> threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads << new MinMaxThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) );
 
         if ( threads.Length() > 1 )
         {
            int i = 0;
            for ( MinMaxThread& thread : threads )
               thread.Start( ThreadPriority::DefaultMax, useAffinity ? i++ : -1 );
            for ( MinMaxThread& thread : threads )
               thread.Wait();
         }
         else
            threads[0].Run();
 
         sample slow = 0, shigh = 0;
         for ( size_type i = 0; i < threads.Length(); ++i )
            if ( threads[i].count > 0 )
            {
               slow = threads[i].min;
               shigh = threads[i].max;
               count = threads[i].count;
               while ( ++i < threads.Length() )
                  if ( threads[i].count > 0 )
                  {
                     if ( threads[i].min < slow )
                        slow = threads[i].min;
                     if ( shigh < threads[i].max )
                        shigh = threads[i].max;
                     count += threads[i].count;
                  }
               break;
            }
 
         threads.Destroy();
 
         low = double( slow );
         high = double( shigh );
      }
 
      if ( count == 0 )
      {
         m_status += N;
         return 0;
      }
 
      if ( k == 1 )
      {
         m_status += N;
         return high/double( P::MaxSampleValue() );
      }
 
      const double eps = P::IsComplexSample() ? 2*std::numeric_limits<double>::epsilon() :
                           (P::IsFloatSample() ? 2*std::numeric_limits<typename P::component>::epsilon() :
                              0.5/Pow2( double( P::BitsPerSample() ) ));
      if ( k == 0 || high - low < eps )
      {
         m_status += N;
         return low/double( P::MaxSampleValue() );
      }
 
      size_type index = size_type( k*(count - 1) );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::FastMedian;
         data.length = N;
         data.overheadLimit = __PCL_MEDIAN_HISTOGRAM_OVERHEAD;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      ReferenceArray<HistogramThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads << new HistogramThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ), low, high );
 
      for ( size_type n = 0;; )
      {
         if ( threads.Length() > 1 )
         {
            int i = 0;
            for ( HistogramThread& thread : threads )
               thread.Start( ThreadPriority::DefaultMax, useAffinity ? i++ : -1 );
            for ( HistogramThread& thread : threads )
               thread.Wait();
         }
         else
            threads[0].Run();
 
         SzVector H = threads[0].H;
         for ( size_type i = 1; i < threads.Length(); ++i )
            H += threads[i].H;
 
         for ( int i = 0; ; n += H[i++] )
            if ( n + H[i] > index )
            {
               double range = high - low;
               high = (range * (i + 1))/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + low;
               low = (range * i)/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + low;
               if ( high - low < eps )
               {
                  threads.Destroy();
                  m_status += N;
                  return low/double( P::MaxSampleValue() );
               }
               break;
            }
      }
   }
 
   double Variance( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                    int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing variance", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumThread> sumThreads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         sumThreads.Add( new SumThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( sumThreads.Length() > 1 )
      {
         int n = 0;
         for ( SumThread& thread : sumThreads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumThread& thread : sumThreads )
            thread.Wait();
      }
      else
         sumThreads[0].Run();
 
      double s = 0;
      double e = 0;
      size_type n = 0;
      for ( const SumThread& thread : sumThreads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
         n += thread.n;
      }
 
      sumThreads.Destroy();
 
      if ( n < 2 )
         return 0;
      double mean = s/n;
 
      ReferenceArray<VarThread> varThreads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         varThreads.Add( new VarThread( *this, mean, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( varThreads.Length() > 1 )
      {
         int n = 0;
         for ( VarThread& thread : varThreads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( VarThread& thread : varThreads )
            thread.Wait();
      }
      else
         varThreads[0].Run();
 
      double var = 0, eps = 0;
      for ( const VarThread& thread : varThreads )
         var += thread.var, eps += thread.eps;
 
      varThreads.Destroy();
      m_status += N;
      return (var - eps*eps/n)/(n - 1);
   }
 
   double StdDev( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                  int maxProcessors = 0 ) const
   {
      return pcl::Sqrt( Variance( rect, firstChannel, lastChannel, maxProcessors ) );
   }
 
   double AvgDev( double center,
                  const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                  int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing average absolute deviation", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumAbsDevThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new SumAbsDevThread( *this, center, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( SumAbsDevThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumAbsDevThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s = 0;
      double e = 0;
      size_type n = 0;
      for ( const SumAbsDevThread& thread : threads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
         n += thread.n;
      }
 
      threads.Destroy();
 
      m_status += N;
 
      if ( n == 0 )
         return 0;
      return s/n;
   }
 
   TwoSidedEstimate TwoSidedAvgDev( double center,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing two-sided average absolute deviation", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<TwoSidedSumAbsDevThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new TwoSidedSumAbsDevThread( *this, center, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( TwoSidedSumAbsDevThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( TwoSidedSumAbsDevThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s0 = 0, s1 = 0;
      double e0 = 0, e1 = 0;
      size_type n0 = 0, n1 = 0;
      for ( const TwoSidedSumAbsDevThread& thread : threads )
      {
         double y = thread.s0 - e0;
         double t = s0 + y;
         e0 = (t - s0) - y;
         s0 = t;
         n0 += thread.n0;
         y = thread.s1 - e1;
         t = s1 + y;
         e1 = (t - s1) - y;
         s1 = t;
         n1 += thread.n1;
      }
 
      threads.Destroy();
 
      m_status += N;
 
      return { (n0 > 0) ? s0/n0 : 0.0,
               (n1 > 0) ? s1/n1 : 0.0 };
   }
 
   double MAD( double center,
               const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
               int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing median absolute deviation", N );
 
      if ( N <= 4096 )
      {
         AbsDevSmpThread S( *this, center, r, firstChannel, lastChannel, 0, r.Height() );
         S.Run();
         if ( S.n == 0 )
         {
            m_status += N;
            return 0;
         }
         double m = *pcl::Select( S.values.Begin(), S.values.At( S.n ), S.n >> 1 );
         if ( S.n & 1 )
         {
            m_status += N;
            return m;
         }
         m = (m + *pcl::Select( S.values.Begin(), S.values.At( S.n ), (S.n >> 1)-1 ))/2;
         m_status += N;
         return m;
      }
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
 
      double low, high;
      size_type count = 0;
      {
         Array<size_type> L;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ReferenceArray<ExtremeAbsDevThread> threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads << new ExtremeAbsDevThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ), center );
 
         if ( threads.Length() > 1 )
         {
            int n = 0;
            for ( ExtremeAbsDevThread& thread : threads )
               thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
            for ( ExtremeAbsDevThread& thread : threads )
               thread.Wait();
         }
         else
            threads[0].Run();
 
         for ( size_type i = 0; i < threads.Length(); ++i )
            if ( threads[i].count > 0 )
            {
               low = threads[i].minAbsDev;
               high = threads[i].maxAbsDev;
               count += threads[i].count;
               while ( ++i < threads.Length() )
                  if ( threads[i].count > 0 )
                  {
                     if ( threads[i].minAbsDev < low )
                        low = threads[i].minAbsDev;
                     if ( threads[i].maxAbsDev > high )
                        high = threads[i].maxAbsDev;
                     count += threads[i].count;
                  }
               break;
            }
 
         threads.Destroy();
      }
 
      const double eps = 2*std::numeric_limits<double>::epsilon();
      if ( count == 0 || high - low < eps )
      {
         m_status += N;
         return 0;
      }
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::FastMedian;
         data.length = N;
         data.overheadLimit = __PCL_MEDIAN_HISTOGRAM_OVERHEAD;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      ReferenceArray<AbsDevHistogramThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads << new AbsDevHistogramThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ), center, low, high );
 
      double mh = 0, l0 = low;
      SzVector H0;
 
      for ( size_type n = 0, n2 = count >> 1, step = 0, it = 0;; ++it )
      {
         SzVector H;
         if ( it == 0 && step )
            H = H0;
         else
         {
            if ( threads.Length() > 1 )
            {
               int i = 0;
               for ( AbsDevHistogramThread& thread : threads )
                  thread.Start( ThreadPriority::DefaultMax, useAffinity ? i++ : -1 );
               for ( AbsDevHistogramThread& thread : threads )
                  thread.Wait();
            }
            else
               threads[0].Run();
 
            H = threads[0].H;
            for ( size_type i = 1; i < threads.Length(); ++i )
               H += threads[i].H;
            if ( it == 0 )
               if ( (count & 1) == 0 )
                  H0 = H;
         }
 
         for ( int i = 0; ; n += H[i++] )
            if ( n + H[i] > n2 )
            {
               double range = high - low;
               high = (range * (i + 1))/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + low;
               low  = (range * i)/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + low;
               if ( high - low < eps )
               {
                  if ( count & 1 )
                  {
                     threads.Destroy();
                     m_status += N;
                     return low;
                  }
                  if ( step )
                  {
                     threads.Destroy();
                     m_status += N;
                     return (low + mh)/2;
                  }
                  mh = low;
                  low = l0;
                  n = 0;
                  --n2;
                  ++step;
                  it = 0;
               }
               break;
            }
      }
   }
 
   TwoSidedEstimate TwoSidedMAD( double center,
                                 const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                 int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing two-sided median absolute deviation", N );
 
      if ( N <= 4096 )
      {
         TwoSidedAbsDevSmpThread S( *this, center, r, firstChannel, lastChannel, 0, r.Height() );
         S.Run();
         m_status += N;
         return { pcl::Median( S.values.Begin(), S.p ),
                  pcl::Median( S.q, S.values.End() ) };
      }
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
 
      double minLow = 0, minHigh = 0, maxLow = 0, maxHigh = 0;
      size_type nLow = 0, nHigh = 0;
      {
         Array<size_type> L;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::MinMax;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ReferenceArray<TwoSidedExtremeAbsDevThread> threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads << new TwoSidedExtremeAbsDevThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ), center );
 
         if ( threads.Length() > 1 )
         {
            int n = 0;
            for ( TwoSidedExtremeAbsDevThread& thread : threads )
               thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
            for ( TwoSidedExtremeAbsDevThread& thread : threads )
               thread.Wait();
         }
         else
            threads[0].Run();
 
         for ( size_type i = 0; i < threads.Length(); ++i )
            if ( threads[i].nLow > 0 )
            {
               minLow = threads[i].minAbsDevLow;
               maxLow = threads[i].maxAbsDevLow;
               nLow = threads[i].nLow;
               while ( ++i < threads.Length() )
                  if ( threads[i].nLow > 0 )
                  {
                     if ( threads[i].minAbsDevLow < minLow )
                        minLow = threads[i].minAbsDevLow;
                     if ( threads[i].maxAbsDevLow > maxLow )
                        maxLow = threads[i].maxAbsDevLow;
                     nLow += threads[i].nLow;
                  }
               break;
            }
 
         for ( size_type i = 0; i < threads.Length(); ++i )
            if ( threads[i].nHigh > 0 )
            {
               minHigh = threads[i].minAbsDevHigh;
               maxHigh = threads[i].maxAbsDevHigh;
               nHigh = threads[i].nHigh;
               while ( ++i < threads.Length() )
                  if ( threads[i].nHigh > 0 )
                  {
                     if ( threads[i].minAbsDevHigh < minHigh )
                        minHigh = threads[i].minAbsDevHigh;
                     if ( threads[i].maxAbsDevHigh > maxHigh )
                        maxHigh = threads[i].maxAbsDevHigh;
                     nHigh += threads[i].nHigh;
                  }
               break;
            }
 
         threads.Destroy();
      }
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::FastMedian;
         data.length = N;
         data.overheadLimit = __PCL_MEDIAN_HISTOGRAM_OVERHEAD;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      int side;
      double sideLow, sideHigh;
      ReferenceArray<TwoSidedAbsDevHistogramThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads << new TwoSidedAbsDevHistogramThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ), center, side, sideLow, sideHigh );
 
      const double eps = 2*std::numeric_limits<double>::epsilon();
      double mad[ 2 ];
      for ( side = 0; side < 2; ++side )
      {
         size_type n = side ? nHigh : nLow;
         if ( n < 2 )
         {
            mad[side] = 0;
            continue;
         }
 
         sideLow = side ? minHigh : minLow;
         sideHigh = side ? maxHigh : maxLow;
         if ( sideHigh - sideLow < eps )
         {
            mad[side] = 0;
            continue;
         }
 
         double mh = 0, h0 = sideHigh;
         SzVector H0;
 
         for ( size_type count = 0, n2 = n >> 1, step = 0, it = 0;; ++it )
         {
            SzVector H;
            if ( it == 0 && step )
               H = H0;
            else
            {
               if ( threads.Length() > 1 )
               {
                  int i = 0;
                  for ( TwoSidedAbsDevHistogramThread& thread : threads )
                     thread.Start( ThreadPriority::DefaultMax, useAffinity ? i++ : -1 );
                  for ( TwoSidedAbsDevHistogramThread& thread : threads )
                     thread.Wait();
               }
               else
                  threads[0].Run();
 
               H = threads[0].H;
               for ( size_type i = 1; i < threads.Length(); ++i )
                  H += threads[i].H;
               if ( it == 0 )
                  if ( (n & 1) == 0 )
                     H0 = H;
            }
 
            for ( int i = 0; ; count += H[i++] )
               if ( count + H[i] > n2 )
               {
                  double range = sideHigh - sideLow;
                  sideHigh = (range * (i + 1))/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + sideLow;
                  sideLow  = (range * i)/(__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) + sideLow;
                  if ( sideHigh - sideLow < eps )
                  {
                     if ( n & 1 )
                     {
                        mad[side] = sideLow;
                        goto __madNextSide;
                     }
                     if ( step )
                     {
                        mad[side] = (sideLow + mh)/2;
                        goto __madNextSide;
                     }
                     mh = sideLow;
                     sideLow = 0;
                     sideHigh = h0;
                     count = 0;
                     --n2;
                     ++step;
                     it = 0;
                  }
                  break;
               }
         }
 
__madNextSide:
;
      }
 
      threads.Destroy();
      m_status += N;
      return { mad[0], mad[1] };
   }
 
   double BiweightMidvariance( double center, double sigma, int k = 9, bool reducedLength = false,
                               const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                               int maxProcessors = 0, bool __performanceAnalysis__ = false ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      double kd = k * sigma;
      if ( kd < 0 || 1 + kd == 1 )
      {
         m_status += N;
         return 0;
      }
 
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing biweight midvariance", N );
 
      Array<size_type> L;
      if ( likely( !__performanceAnalysis__ ) )
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::BiweightMidvariance;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      else
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, 1/*overheadLimitPx*/ );
 
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<BWMVThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new BWMVThread( *this, center, kd, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( BWMVThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( BWMVThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double num = 0, den = 0;
      size_type n = 0, nr = 0;
      for ( const BWMVThread& thread : threads )
      {
         num += thread.num;
         den += thread.den;
         n += thread.n;
         nr += thread.nr;
      }
 
      threads.Destroy();
 
      m_status += N;
      den *= den;
      return (n >= 2 && 1 + den != 1) ? (reducedLength ? nr : n)*num/den : 0.0;
   }
 
   TwoSidedEstimate TwoSidedBiweightMidvariance( double center, const TwoSidedEstimate& sigma, int k = 9, bool reducedLength = false,
                                                 const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                                 int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      double kd0 = k * sigma.low;
      double kd1 = k * sigma.high;
      if ( kd0 < 0 || 1 + kd0 == 1 || kd1 < 0 || 1 + kd1 == 1 )
      {
         m_status += N;
         return 0;
      }
 
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing two-sided biweight midvariance", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::BiweightMidvariance;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<TwoSidedBWMVThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new TwoSidedBWMVThread( *this, center, kd0, kd1, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( TwoSidedBWMVThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( TwoSidedBWMVThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double num0 = 0, den0 = 0, num1 = 0, den1 = 0;
      size_type n0 = 0, n1 = 0, nr0 = 0, nr1 = 0;
      for ( const TwoSidedBWMVThread& thread : threads )
      {
         num0 += thread.num0;
         den0 += thread.den0;
         num1 += thread.num1;
         den1 += thread.den1;
         n0 += thread.n0;
         n1 += thread.n1;
         nr0 += thread.nr0;
         nr1 += thread.nr1;
      }
 
      threads.Destroy();
 
      m_status += N;
 
      den0 *= den0;
      den1 *= den1;
      return { (n0 >= 2 && 1 + den0 != 1) ? (reducedLength ? nr0 : n0)*num0/den0 : 0.0,
               (n1 >= 2 && 1 + den1 != 1) ? (reducedLength ? nr1 : n1)*num1/den1 : 0.0 };
   }
 
   double BendMidvariance( double center, double beta = 0.2,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                           int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing percentage bend midvariance", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sampling;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<DSmpThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new DSmpThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( DSmpThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( DSmpThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      Array<double> values;
      for ( DSmpThread& thread : threads )
         if ( thread.n > 0 )
         {
            values.Add( thread.values.Begin(), thread.values.At( thread.n ) );
            thread.values.Clear();
         }
 
      threads.Destroy();
 
      double pbmv = pcl::BendMidvariance( values.Begin(), values.End(), center, beta );
      m_status += N;
      return pbmv;
   }
 
   double Sn( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1, int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing Sn scale estimate", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sampling;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<DSmpThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new DSmpThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( DSmpThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( DSmpThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      Array<double> values;
      for ( DSmpThread& thread : threads )
         if ( thread.n > 0 )
         {
            values.Add( thread.values.Begin(), thread.values.At( thread.n ) );
            thread.values.Clear();
         }
 
      threads.Destroy();
 
      double sn = pcl::Sn( values.Begin(), values.End() );
      m_status += N;
      return sn;
   }
 
   double Qn( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1, int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing Qn scale estimate", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sampling;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<DSmpThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new DSmpThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( DSmpThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( DSmpThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      Array<double> values;
      for ( DSmpThread& thread : threads )
         if ( thread.n > 0 )
         {
            values.Add( thread.values.Begin(), thread.values.At( thread.n ) );
            thread.values.Clear();
         }
 
      threads.Destroy();
 
      double qn = pcl::Qn( values.Begin(), values.End() );
      m_status += N;
      return qn;
   }
 
   double Norm( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing norm", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new SumThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( SumThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s = 0;
      double e = 0;
      for ( const SumThread& thread : threads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
      }
 
      threads.Destroy();
      m_status += N;
      return (1 + s != 1) ? s : 0.0; // don't return insignificant nonzero values
   }
 
   double Modulus( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                   int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing modulus", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumAbsThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new SumAbsThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( SumAbsThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumAbsThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s = 0;
      double e = 0;
      for ( const SumAbsThread& thread : threads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
      }
 
      threads.Destroy();
      m_status += N;
      return (1 + s != 1) ? s : 0.0; // don't return insignificant nonzero values
   }
 
   double SumOfSquares( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                        int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing sum of squares", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumSqrThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new SumSqrThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( SumSqrThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumSqrThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s = 0;
      double e = 0;
      for ( const SumSqrThread& thread : threads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
      }
 
      threads.Destroy();
      m_status += N;
      return (1 + s != 1) ? s : 0.0; // don't return insignificant nonzero values
   }
 
   double MeanOfSquares( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                         int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing mean of squares", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<SumSqrThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new SumSqrThread( *this, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( SumSqrThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( SumSqrThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      double s = 0;
      double e = 0;
      size_type n = 0;
      for ( const SumSqrThread& thread : threads )
      {
         double y = thread.s - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
         n += thread.n;
      }
 
      threads.Destroy();
 
      m_status += N;
 
      if ( n < 1 )
         return 0;
      return s/n;
   }
 
   Vector Norms( int maxDegree = 2, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                 int maxProcessors = 0 ) const
   {
      PCL_PRECONDITION( maxDegree > 0 )
      maxDegree = pcl::Max( 1, maxDegree );
 
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return 0;
 
      size_type N = r.IntegerArea()*(1 + lastChannel - firstChannel);
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Computing norms", N );
 
      Array<size_type> L;
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::Sum;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
      }
      bool useAffinity = m_parallel && Thread::IsRootThread();
      ReferenceArray<NormThread> threads;
      for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
         threads.Add( new NormThread( *this, maxDegree, r, firstChannel, lastChannel, n, n + int( L[i] ) ) );
      if ( threads.Length() > 1 )
      {
         int n = 0;
         for ( NormThread& thread : threads )
            thread.Start( ThreadPriority::DefaultMax, useAffinity ? n++ : -1 );
         for ( NormThread& thread : threads )
            thread.Wait();
      }
      else
         threads[0].Run();
 
      Vector R( 0.0, maxDegree );
      Vector e( 0.0, maxDegree );
      for ( const NormThread& thread : threads )
         for ( int i = 0; i < maxDegree; ++i )
         {
            double y = thread.R[i] - e[i];
            double t = R[i] + y;
            e[i] = (t - R[i]) - y;
            R[i] = t;
         }
      for ( int i = 0; i < maxDegree; ++i )
         if ( 1 + R[i] == 1 ) // don't return insignificant nonzero values
            R[i] = 0;
 
      threads.Destroy();
      m_status += N;
      return R;
   }
 
   uint64 Hash64( int channel = -1, uint64 seed = 0 ) const noexcept
   {
      if ( !ParseChannel( channel ) )
         return 0;
      return pcl::Hash64( m_channelData( channel ), ChannelSize(), seed );
   }
 
   uint32 Hash32( int channel = -1, uint32 seed = 0 ) const noexcept
   {
      if ( !ParseChannel( channel ) )
         return 0;
      return pcl::Hash32( m_channelData( channel ), ChannelSize(), seed );
   }
 
   uint64 Hash( int channel = -1, uint64 seed = 0 ) const noexcept
   {
      return Hash64( channel, seed );
   }
 
   // -------------------------------------------------------------------------
 
   GenericImage& Write( File& file, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, firstChannel, lastChannel ) )
         return const_cast<GenericImage&>( *this );
 
      size_type N = r.IntegerArea();
      int numberOfChannels = 1 + lastChannel - firstChannel;
 
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "Writing to raw-storage image stream", N*numberOfChannels );
 
      file.WriteUI32( r.Width() );
      file.WriteUI32( r.Height() );
      file.WriteUI32( numberOfChannels );
      file.WriteUI32( (firstChannel == 0 && lastChannel >= 2) ? m_colorSpace : ColorSpace::Gray );
 
      if ( r == Bounds() )
      {
         for ( int i = firstChannel; i <= lastChannel; ++i, m_status += N )
            file.Write( (const void*)m_pixelData[i], fsize_type( ChannelSize() ) );
      }
      else
      {
         for ( int i = firstChannel, w = r.Width(), h = r.Height(); i <= lastChannel; ++i )
         {
            const sample* p = PixelAddress( r.LeftTop(), i );
            for ( int j = 0; j < h; ++j, p += m_width, m_status += w )
               file.Write( (const void*)p, w*BytesPerSample() );
         }
      }
 
      return const_cast<GenericImage&>( *this );
   }
 
   GenericImage& Write( const String& filePath,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      File file = File::CreateFileForWriting( filePath );
      return Write( file, rect, firstChannel, lastChannel );
   }
 
   GenericImage& Read( File& file )
   {
      int width, height, numberOfChannels, colorSpace;
      file.ReadUI32( width );
      file.ReadUI32( height );
      file.ReadUI32( numberOfChannels );
      file.ReadUI32( colorSpace );
 
      AllocateData( width, height, numberOfChannels, color_space( colorSpace ) );
 
      ResetSelections();
 
      size_type N = NumberOfPixels();
      if ( N > 0 )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Reading from raw-storage image stream", N*m_numberOfChannels );
         for ( int i = 0; i < m_numberOfChannels; ++i, m_status += N )
            file.Read( (void*)m_pixelData[i], fsize_type( ChannelSize() ) );
      }
 
      return *this;
   }
 
   GenericImage& Read( const String& filePath )
   {
      File file = File::OpenFileForReading( filePath );
      return Read( file );
   }
 
   // -------------------------------------------------------------------------
 
   template <typename T>
   GenericImage& CropBy( int left, int top, int right, int bottom, const GenericVector<T>& fillValues )
   {
      if ( left == 0 && top == 0 && right == 0 && bottom == 0 )
         return *this;
 
      if ( m_width+left+right <= 0 || m_height+top+bottom <= 0 )
      {
         FreeData();
         return *this;
      }
 
      Rect r( -left, -top, m_width+right, m_height+bottom );
      int width = r.Width();
      int height = r.Height();
 
      if ( !Intersects( r ) )
         return AllocateData( width, height, m_numberOfChannels, m_colorSpace ).Fill( fillValues );
 
      size_type N = size_type( width )*size_type( height );
 
      EnsureUnique();
 
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( String().Format( "Crop margins: %+d, %+d, %+d, %+d",
                                               left, top, right, bottom ), N*m_numberOfChannels );
 
      sample** newData = nullptr;
 
      try
      {
         newData = m_allocator.AllocateChannelSlots( m_numberOfChannels );
 
         for ( int c = 0; c < m_numberOfChannels; ++c, m_status += N )
         {
            sample* __restrict__ f = newData[c] = m_allocator.AllocatePixels( N );
            sample v = (c < fillValues.Length()) ? P::ToSample( fillValues[c] ) : P::MinSampleValue();
 
            for ( int i = r.y0, j; i < r.y1; )
            {
               for ( ; i < 0; ++i )
               {
                  PCL_IVDEP
                  for ( int j = 0; j < width; ++j )
                     *f++ = v;
               }
 
               PCL_IVDEP
               for ( j = r.x0; j < 0; ++j )
                  *f++ = v;
 
               for ( const sample* f0 = PixelAddress( j, i, c ); j < r.x1; )
               {
                  *f++ = *f0++;
                  if ( ++j == m_width )
                  {
                     PCL_IVDEP
                     for ( ; j < r.x1; ++j )
                        *f++ = v;
                  }
               }
 
               if ( ++i == m_height )
                  for ( ; i < r.y1; ++i )
                  {
                     PCL_IVDEP
                     for ( int j = 0; j < width; ++j )
                        *f++ = v;
                  }
            }
         }
 
         try
         {
            for ( int c = 0; c < m_numberOfChannels; ++c )
            {
               m_allocator.Deallocate( m_pixelData[c] );
               m_pixelData[c] = newData[c];
            }
            m_allocator.Deallocate( newData );
            newData = nullptr;
 
            m_allocator.SetSharedGeometry( m_width = width, m_height = height, m_numberOfChannels );
 
            ResetPoint();
            ResetSelection();
            return *this;
         }
         catch ( ... )
         {
            m_data->Deallocate();
            ResetSelections();
            throw;
         }
      }
      catch ( ... )
      {
         if ( newData != nullptr )
         {
            for ( int i = 0; i < m_numberOfChannels; ++i )
               if ( newData[i] != nullptr )
                  m_allocator.Deallocate( newData[i] ), newData[i] = nullptr;
            m_allocator.Deallocate( newData );
         }
         throw;
      }
   }
 
   GenericImage& CropBy( int left, int top, int right, int bottom )
   {
      return CropBy( left, top, right, bottom, sample_vector() );
   }
 
   template <typename T>
   GenericImage& CropTo( const Rect& rect, const GenericVector<T>& fillValues )
   {
      Rect r = rect.Ordered();
      return CropBy( -r.x0, -r.y0, r.x1 - m_width, r.y1 - m_height, fillValues );
   }
 
   GenericImage& CropTo( const Rect& rect )
   {
      return CropTo( rect, sample_vector() );
   }
 
   template <typename T>
   GenericImage& CropTo( int x0, int y0, int x1, int y1, const GenericVector<T>& fillValues )
   {
      return CropTo( Rect( x0, y0, x1, y1 ), fillValues );
   }
 
   GenericImage& CropTo( int x0, int y0, int x1, int y1 )
   {
      return CropTo( x0, y0, x1, y1, sample_vector() );
   }
 
   template <typename T>
   GenericImage& Crop( const GenericVector<T>& fillValues )
   {
      return CropTo( m_rectangle, fillValues );
   }
 
   GenericImage& Crop()
   {
      return Crop( sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftBy( int dx, int dy, const GenericVector<T>& fillValues )
   {
      return CropBy( dx, dy, -dx, -dy, fillValues );
   }
 
   GenericImage& ShiftBy( int dx, int dy )
   {
      return ShiftBy( dx, dy, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftTo( int x, int y, const GenericVector<T>& fillValues )
   {
      return ShiftBy( x, y, fillValues );
   }
 
   GenericImage& ShiftTo( int x, int y )
   {
      return ShiftTo( x, y, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftTo( const Point& p, const GenericVector<T>& fillValues )
   {
      return ShiftBy( p.x, p.y, fillValues );
   }
 
   GenericImage& ShiftTo( const Point& p )
   {
      return ShiftTo( p, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftToCenter( int width, int height, const GenericVector<T>& fillValues )
   {
      int dx2 = (width - m_width) >> 1;
      int dy2 = (height - m_height) >> 1;
      return CropBy( dx2, dy2, width-m_width-dx2, height-m_height-dy2, fillValues );
   }
 
   GenericImage& ShiftToCenter( int width, int height )
   {
      return ShiftToCenter( width, height, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftToTopLeft( int width, int height, const GenericVector<T>& fillValues )
   {
      int dx = width - m_width;
      int dy = height - m_height;
      return CropBy( 0, 0, dx, dy, fillValues );
   }
 
   GenericImage& ShiftToTopLeft( int width, int height )
   {
      return ShiftToTopLeft( width, height, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftToTopRight( int width, int height, const GenericVector<T>& fillValues )
   {
      int dx = width - m_width;
      int dy = height - m_height;
      return CropBy( dx, 0, 0, dy, fillValues );
   }
 
   GenericImage& ShiftToTopRight( int width, int height )
   {
      return ShiftToTopRight( width, height, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftToBottomLeft( int width, int height, const GenericVector<T>& fillValues )
   {
      int dx = width - m_width;
      int dy = height - m_height;
      return CropBy( 0, dy, dx, 0, fillValues );
   }
 
   GenericImage& ShiftToBottomLeft( int width, int height )
   {
      return ShiftToBottomLeft( width, height, sample_vector() );
   }
 
   template <typename T>
   GenericImage& ShiftToBottomRight( int width, int height, const GenericVector<T>& fillValues )
   {
      int dx = width - m_width;
      int dy = height - m_height;
      return CropBy( dx, dy, 0, 0, fillValues );
   }
 
   GenericImage& ShiftToBottomRight( int width, int height )
   {
      return ShiftToBottomRight( width, height, sample_vector() );
   }
 
   template <typename T>
   GenericImage& Shift( const GenericVector<T>& fillValues )
   {
      return ShiftTo( m_point, fillValues );
   }
 
   GenericImage& Shift()
   {
      return Shift( sample_vector() );
   }
 
   // -------------------------------------------------------------------------
 
   GenericImage& SetColorSpace( color_space colorSpace, int maxProcessors = 0, bool __performanceAnalysis__ = false )
   {
      size_type N = NumberOfPixels();
      if ( N == 0 )
         return *this;
 
      if ( colorSpace == m_colorSpace )
      {
         m_status += N;
         return *this;
      }
 
      EnsureUnique();
 
      if ( m_status.IsInitializationEnabled() )
         m_status.Initialize( "In-place color space conversion: "
                            + ColorSpace::Name( m_colorSpace )
                            + " -> "
                            + ColorSpace::Name( colorSpace ), N );
 
      int n = m_numberOfChannels;
 
      if ( m_colorSpace == ColorSpace::Gray )
      {
         sample** oldData = m_pixelData;
         sample** newData = nullptr;
 
         try
         {
            // Make room for the G and B channels.
            newData = m_allocator.AllocateChannelSlots( 2+n );
 
            // Put the nominal gray channel into the R slot
            newData[0] = oldData[0];
 
            // Allocate and copy the G and B channels
            newData[1] = m_allocator.AllocatePixels( N );
            ::memcpy( newData[1], oldData[0], ChannelSize() );
            newData[2] = m_allocator.AllocatePixels( N );
            ::memcpy( newData[2], oldData[0], ChannelSize() );
 
            // Put existing alpha channels in their corresponding slots
            for ( int i = 1; i < n; ++i )
               newData[i+2] = oldData[i];
 
            try
            {
               m_pixelData = newData;
               newData = nullptr;
               m_numberOfChannels += 2;
               m_colorSpace = ColorSpace::RGB;
               m_data->UpdateSharedImage();
 
               ResetChannelRange();
 
               m_allocator.Deallocate( oldData );
            }
            catch ( ... )
            {
               m_data->Deallocate();
               ResetSelections();
               throw;
            }
         }
         catch ( ... )
         {
            if ( newData != nullptr )
            {
               newData[0] = nullptr;
               if ( newData[1] != nullptr )
                  m_allocator.Deallocate( newData[1] ), newData[1] = nullptr;
               if ( newData[2] != nullptr )
                  m_allocator.Deallocate( newData[2] ), newData[2] = nullptr;
               m_allocator.Deallocate( newData );
               throw;
            }
         }
 
         if ( colorSpace == ColorSpace::RGB )
         {
            m_status += N;
            return *this;
         }
 
         n += 2;
      }
 
      Array<size_type> L;
      if ( likely( !__performanceAnalysis__ ) )
      {
         Thread::PerformanceAnalysisData data;
         data.algorithm = PerformanceAnalysisAlgorithm::ColorSpaceConversion;
         data.length = N;
         data.overheadLimit = 32768;
         data.itemSize = BytesPerSample();
         data.floatingPoint = IsFloatSample();
         L = Thread::OptimalThreadLoads( N, N/Thread::OptimalNumberOfThreads( data )/*overheadLimit*/,
                                         m_parallel ? ((maxProcessors > 0) ? maxProcessors : m_maxProcessors) : 1 );
      }
      else
         L = Thread::OptimalThreadLoads( N, 1/*overheadLimit*/, maxProcessors );
 
      ThreadData data( *this, N );
      ReferenceArray<ColorSpaceConversionThread> threads;
      for ( size_type i = 0, n = 0; i < L.Length(); n += L[i++] )
         threads.Add( new ColorSpaceConversionThread( *this, data, colorSpace, n, n + L[i] ) );
      RunThreads( threads, data );
      threads.Destroy();
 
      m_status = data.status;
 
      if ( colorSpace == ColorSpace::Gray )
      {
         sample** oldData = m_pixelData;
         sample** newData = nullptr;
 
         try
         {
            newData = m_allocator.AllocateChannelSlots( n-2 );
            newData[0] = oldData[0];
            for ( int i = 3; i < n; ++i )
               newData[i-2] = oldData[i];
 
            m_pixelData = newData;
            newData = nullptr;
            m_numberOfChannels -= 2;
            m_colorSpace = ColorSpace::Gray;
            m_data->UpdateSharedImage();
 
            ResetChannelRange();
 
            m_allocator.Deallocate( oldData[1] );
            m_allocator.Deallocate( oldData[2] );
            m_allocator.Deallocate( oldData );
         }
         catch ( ... )
         {
            m_data->Deallocate();
            ResetSelections();
            if ( newData != nullptr )
               m_allocator.Deallocate( newData );
            throw;
         }
      }
      else
      {
         m_allocator.SetSharedColor( m_colorSpace = colorSpace, m_RGBWS );
      }
 
      return *this;
   }
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   void GetLuminance( GenericImage<P1>& Y, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const
   {
      Rect r = rect;
      if ( !ParseRect( r ) )
      {
         Y.FreeData();
         return;
      }
 
      Y.AllocateData( r );
      if ( !Y.IsShared() )
         Y.SetRGBWorkingSpace( m_RGBWS );
 
      size_type N = Y.NumberOfPixels();
 
      if ( m_colorSpace == ColorSpace::Gray || m_colorSpace == ColorSpace::CIEXYZ )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Transferring pixel data", N );
 
         typename GenericImage<P1>::sample* __restrict__ g = *Y;
         int cY = (m_colorSpace == ColorSpace::Gray) ? 0 : 1;
         if ( r == Bounds() )
         {
            const sample* __restrict__ f = m_pixelData[cY];
            P1::Copy( g, f, N );
         }
         else
         {
            const sample* __restrict__ f = PixelAddress( r.LeftTop(), cY );
            for ( int i = 0; i < Y.Height(); ++i, f += m_width, g += Y.Width() )
               P1::Copy( g, f, Y.Width() );
         }
 
         m_status += N;
      }
      else
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Computing CIE Y component", N );
 
         Array<size_type> L;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::GetLightness;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( Y.Height(), Y.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ThreadData data( *this, N );
         ReferenceArray<GetLuminanceThread<P1>> threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads.Add( new GetLuminanceThread<P1>( Y, *this, data, r, n, n + int( L[i] ) ) );
         RunThreads( threads, data );
         threads.Destroy();
 
         m_status = data.status;
      }
   }
 
   void GetLuminance( ImageVariant& Y, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const;
   // Implemented in pcl/ImageVariant.h
 
   template <class P1>
   void GetLightness( GenericImage<P1>& L, const Rect& rect = Rect( 0 ), int maxProcessors = 0,
                      bool __performanceAnalysis__ = false ) const
   {
      Rect r = rect;
      if ( !ParseRect( r ) )
      {
         L.FreeData();
         return;
      }
 
      L.AllocateData( r );
      if ( !L.IsShared() )
         L.SetRGBWorkingSpace( m_RGBWS );
 
      size_type N = L.NumberOfPixels();
 
      if ( m_colorSpace == ColorSpace::Gray || m_colorSpace == ColorSpace::CIELab || m_colorSpace == ColorSpace::CIELch )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Transferring pixel data", N );
 
         typename GenericImage<P1>::sample* g = *L;
         if ( r == Bounds() )
         {
            const sample* __restrict__ f = *m_pixelData;
            P1::Copy( g, f, N );
         }
         else
         {
            const sample* __restrict__ f = PixelAddress( r.LeftTop() );
            for ( int i = 0; i < L.Height(); ++i, f += m_width, g += L.Width() )
               P1::Copy( g, f, L.Width() );
         }
 
         m_status += N;
      }
      else
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Computing CIE L* component", N );
 
         Array<size_type> R;
         if ( likely( !__performanceAnalysis__ ) )
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::GetLightness;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            R = OptimalThreadRows( L.Height(), L.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         else
            R = OptimalThreadRows( L.Height(), L.Width(), maxProcessors, 1/*overheadLimitPx*/ );
 
         ThreadData data( *this, N );
         ReferenceArray<GetLightnessThread<P1> > threads;
         for ( int i = 0, n = 0; i < int( R.Length() ); n += int( R[i++] ) )
            threads.Add( new GetLightnessThread<P1>( L, *this, data, r, n, n + int( R[i] ) ) );
         RunThreads( threads, data );
         threads.Destroy();
 
         m_status = data.status;
      }
   }
 
   void GetLightness( ImageVariant& L, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const;
   // Implemented in pcl/ImageVariant.h
 
   template <class P1>
   void GetIntensity( GenericImage<P1>& I, const Rect& rect = Rect( 0 ), int maxProcessors = 0,
                      bool __performanceAnalysis__ = false ) const
   {
      Rect r = rect;
      if ( !ParseRect( r ) )
      {
         I.FreeData();
         return;
      }
 
      I.AllocateData( r );
      if ( !I.IsShared() )
         I.SetRGBWorkingSpace( m_RGBWS );
 
      size_type N = I.NumberOfPixels();
 
      if ( m_colorSpace == ColorSpace::Gray || m_colorSpace == ColorSpace::HSI )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Transferring pixel data", N );
 
         typename GenericImage<P1>::sample* __restrict__ g = *I;
         int cI = (m_colorSpace == ColorSpace::Gray) ? 0 : 2;
         if ( r == Bounds() )
         {
            const sample* __restrict__ f = m_pixelData[cI];
            P1::Copy( g, f, N );
         }
         else
         {
            const sample* __restrict__ f = PixelAddress( r.LeftTop(), cI );
            for ( int i = 0; i < I.Height(); ++i, f += m_width, g += I.Width() )
               P1::Copy( g, f, I.Width() );
         }
 
         m_status += N;
      }
      else
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Computing intensity component", N );
 
         Array<size_type> L;
         if ( likely( !__performanceAnalysis__ ) )
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::GetIntensity;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( I.Height(), I.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         else
            L = OptimalThreadRows( I.Height(), I.Width(), maxProcessors, 1/*overheadLimitPx*/ );
 
         ThreadData data( *this, N );
         ReferenceArray<GetIntensityThread<P1> > threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads.Add( new GetIntensityThread<P1>( I, *this, data, r, n, n + int( L[i] ) ) );
         RunThreads( threads, data );
         threads.Destroy();
 
         m_status = data.status;
      }
   }
 
   void GetIntensity( ImageVariant& I, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const;
   // Implemented in pcl/ImageVariant.h
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   GenericImage& SetLuminance( const GenericImage<P1>& Y,
                               const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ),
                               int maxProcessors = 0 )
   {
      Rect r = rect;
      if ( !Y.ParseRect( r ) )
         return *this;
 
      Point p = point;
      if ( p.x == int_max || p.y == int_max )
         p = m_point;
 
      if ( p.x < 0 )
      {
         if ( (r.x0 -= p.x) >= r.x1 )
            return *this;
         p.x = 0;
      }
      else if ( p.x >= m_width )
         return *this;
 
      if ( p.y < 0 )
      {
         if ( (r.y0 -= p.y) >= r.y1 )
            return *this;
         p.y = 0;
      }
      else if ( p.y >= m_height )
         return *this;
 
      r.ResizeTo( pcl::Min( m_width - p.x, r.Width() ),
                  pcl::Min( m_height - p.y, r.Height() ) );
 
      size_type N = r.IntegerArea();
 
      EnsureUnique();
 
      if (   m_colorSpace == ColorSpace::Gray &&
          (Y.ColorSpace() == ColorSpace::Gray || Y.ColorSpace() == ColorSpace::CIEXYZ) )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Transferring pixel data", N );
 
         int c0 = (Y.ColorSpace() == ColorSpace::Gray) ? 0 : 1;
         const typename GenericImage<P1>::sample* __restrict__ g = Y.PixelAddress( r.LeftTop(), c0 );
         sample* __restrict__ f = PixelAddress( p );
         for ( int i = 0, w = r.Width(), h = r.Height(); i < h; ++i, f += m_width, g += Y.Width(), m_status += w )
            P::Copy( f, g, w );
      }
      else
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Importing CIE Y component", N );
 
         Array<size_type> L;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::GetLightness;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            L = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ThreadData data( *this, N );
         ReferenceArray<SetLuminanceThread<P1> > threads;
         for ( int i = 0, n = 0; i < int( L.Length() ); n += int( L[i++] ) )
            threads.Add( new SetLuminanceThread<P1>( *this, Y, data, p, r, n, n + int( L[i] ) ) );
         RunThreads( threads, data );
         threads.Destroy();
 
         m_status = data.status;
      }
 
      return *this;
   }
 
   GenericImage& SetLuminance( const ImageVariant& Y,
                               const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ),
                               int maxProcessors = 0 );
   // Implemented in pcl/ImageVariant.h
 
   template <class P1>
   GenericImage& SetLightness( const GenericImage<P1>& L,
                               const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ),
                               int maxProcessors = 0 )
   {
      Rect r = rect;
      if ( !L.ParseRect( r ) )
         return *this;
 
      Point p = point;
      if ( p.x == int_max || p.y == int_max )
         p = m_point;
 
      if ( p.x < 0 )
      {
         if ( (r.x0 -= p.x) >= r.x1 )
            return *this;
         p.x = 0;
      }
      else if ( p.x >= m_width )
         return *this;
 
      if ( p.y < 0 )
      {
         if ( (r.y0 -= p.y) >= r.y1 )
            return *this;
         p.y = 0;
      }
      else if ( p.y >= m_height )
         return *this;
 
      r.ResizeTo( pcl::Min( m_width - p.x, r.Width() ),
                  pcl::Min( m_height - p.y, r.Height() ) );
 
      size_type N = r.IntegerArea();
 
      EnsureUnique();
 
      if (   m_colorSpace == ColorSpace::Gray &&
          (L.ColorSpace() == ColorSpace::Gray ||
           L.ColorSpace() == ColorSpace::CIELab || L.ColorSpace() == ColorSpace::CIELch) )
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Transferring pixel data", N );
 
         const typename GenericImage<P1>::sample* __restrict__ g = L.PixelAddress( r.LeftTop() );
         sample* __restrict__ f = PixelAddress( p );
         for ( int i = 0, w = r.Width(), h = r.Height(); i < h; ++i, f += m_width, g += L.Width(), m_status += w )
            P::Copy( f, g, w );
      }
      else
      {
         if ( m_status.IsInitializationEnabled() )
            m_status.Initialize( "Importing CIE L* component", N );
 
         Array<size_type> R;
         {
            Thread::PerformanceAnalysisData data;
            data.algorithm = PerformanceAnalysisAlgorithm::GetLightness;
            data.length = N;
            data.overheadLimit = 32768;
            data.itemSize = BytesPerSample();
            data.floatingPoint = IsFloatSample();
            R = OptimalThreadRows( r.Height(), r.Width(), maxProcessors, N/Thread::OptimalNumberOfThreads( data )/*overheadLimitPx*/ );
         }
         ThreadData data( *this, N );
         ReferenceArray<SetLightnessThread<P1> > threads;
         for ( int i = 0, n = 0; i < int( R.Length() ); n += int( R[i++] ) )
            threads.Add( new SetLightnessThread<P1>( *this, L, data, p, r, n, n + int( R[i] ) ) );
         RunThreads( threads, data );
         threads.Destroy();
 
         m_status = data.status;
      }
 
      return *this;
   }
 
   GenericImage& SetLightness( const ImageVariant& L,
                               const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ),
                               int maxProcessors = 0 );
   // Implemented in pcl/ImageVariant.h
 
   Compression::subblock_list Compress( const Compression& compressor,
                                        const Rect& rect = Rect( 0 ), int channel = -1,
                                        Compression::Performance* perf = nullptr ) const
   {
      Rect r = rect;
      if ( !ParseSelection( r, channel ) )
         return Compression::subblock_list();
      if ( r == Bounds() )
         return compressor.Compress( m_channelData( channel ), ChannelSize(), perf );
      GenericImage<P> subimage( *this, r, channel, channel );
      return compressor.Compress( subimage[0], subimage.ChannelSize(), perf );
   }
 
   // -------------------------------------------------------------------------
 
private:
 
   struct Data : public ReferenceCounter
   {
      sample**        data = nullptr;
 
      pixel_allocator allocator;
 
      Geometry        geometry;
 
      Color           color;
 
      Data( GenericImage* image )
      {
         LinkWithClientImage( image );
      }
 
      Data( GenericImage* image, void* handle )
         : allocator( handle )
      {
         SynchronizeWithSharedImage();
         LinkWithClientImage( image );
      }
 
      Data( GenericImage* image, int width, int height, int numberOfChannels, int colorSpace )
         : allocator( width, height, numberOfChannels, colorSpace )
      {
         SynchronizeWithSharedImage();
         LinkWithClientImage( image );
      }
 
      void Attach( GenericImage* image )
      {
         ReferenceCounter::Attach();
         LinkWithClientImage( image );
      }
 
      ~Data()
      {
         if ( IsShared() )
            Reset();
         else
            Deallocate();
      }
 
      bool IsShared() const noexcept
      {
         return allocator.IsShared();
      }
 
      bool IsEmpty() const noexcept
      {
         return data == nullptr;
      }
 
      void Allocate( int width, int height, int numberOfChannels, color_space colorSpace )
      {
         if ( width <= 0 || height <= 0 || numberOfChannels <= 0 )
         {
            Deallocate();
            return;
         }
 
         if ( numberOfChannels < ColorSpace::NumberOfNominalChannels( colorSpace ) )
            throw Error( "GenericImage::Data::Allocate(): Insufficient number of channels" );
 
         if ( data != nullptr )
         {
            if ( size_type( width )*size_type( height ) == geometry.NumberOfPixels() )
            {
               if ( numberOfChannels != geometry.numberOfChannels )
               {
                  sample** newData = nullptr;
                  int m = pcl::Min( geometry.numberOfChannels, numberOfChannels );
 
                  try
                  {
                     newData = allocator.AllocateChannelSlots( numberOfChannels );
                     for ( int i = 0; i < m; ++i )
                        newData[i] = data[i];
                     for ( int i = m; i < numberOfChannels; ++i )
                        newData[i] = allocator.AllocatePixels( width, height );
 
                     try
                     {
                        for ( int i = m; i < geometry.numberOfChannels; ++i )
                           if ( data[i] != nullptr )
                              allocator.Deallocate( data[i] ), data[i] = nullptr;
                        allocator.Deallocate( data );
                        data = newData;
                        newData = nullptr;
                     }
                     catch ( ... )
                     {
                        Deallocate();
                        throw;
                     }
                  }
                  catch ( ... )
                  {
                     if ( newData != nullptr )
                     {
                        for ( int i = m; i < numberOfChannels; ++i )
                           if ( newData[i] != nullptr )
                              allocator.Deallocate( newData[i] ), newData[i] = nullptr;
                        allocator.Deallocate( newData );
                     }
                     throw;
                  }
               }
            }
            else
            {
               sample** newData = nullptr;
 
               try
               {
                  newData = allocator.AllocateChannelSlots( numberOfChannels );
                  for ( int i = 0; i < numberOfChannels; ++i )
                     newData[i] = allocator.AllocatePixels( width, height );
 
                  try
                  {
                     for ( int i = 0; i < geometry.numberOfChannels; ++i )
                        if ( data[i] != nullptr )
                           allocator.Deallocate( data[i] ), data[i] = nullptr;
                     allocator.Deallocate( data );
                     data = newData;
                     newData = nullptr;
                  }
                  catch ( ... )
                  {
                     Deallocate();
                     throw;
                  }
               }
               catch ( ... )
               {
                  if ( newData != nullptr )
                  {
                     for ( int i = 0; i < numberOfChannels; ++i )
                        if ( newData[i] != nullptr )
                           allocator.Deallocate( newData[i] ), newData[i] = nullptr;
                     allocator.Deallocate( newData );
                  }
                  throw;
               }
            }
         }
         else
         {
            try
            {
               data = allocator.AllocateChannelSlots( numberOfChannels );
               for ( int i = 0; i < numberOfChannels; ++i )
                  data[i] = allocator.AllocatePixels( width, height );
            }
            catch ( ... )
            {
               if ( data != nullptr )
               {
                  for ( int i = 0; i < numberOfChannels; ++i )
                     if ( data[i] != nullptr )
                        allocator.Deallocate( data[i] ), data[i] = nullptr;
                  allocator.Deallocate( data );
                  Reset();
               }
               throw;
            }
         }
 
         geometry.width = width;
         geometry.height = height;
         geometry.numberOfChannels = numberOfChannels;
 
         color.colorSpace = colorSpace;
 
         UpdateSharedImage();
      }
 
      void Import( sample** newData, int width, int height, int numberOfChannels, color_space colorSpace )
      {
         if ( newData != data )
         {
            Deallocate();
 
            if ( newData != nullptr && width > 0 && height > 0 && numberOfChannels > 0 )
            {
               if ( numberOfChannels < ColorSpace::NumberOfNominalChannels( colorSpace ) )
                  throw Error( "GenericImage::Data::Import(): Insufficient number of channels" );
 
               data = newData;
 
               geometry.width = width;
               geometry.height = height;
               geometry.numberOfChannels = numberOfChannels;
 
               color.colorSpace = colorSpace;
 
               UpdateSharedImage();
            }
         }
      }
 
      sample** Release()
      {
         sample** oldData = data;
         Reset();
         UpdateSharedImage();
         return oldData;
      }
 
      void Deallocate()
      {
         if ( data != nullptr )
         {
            for ( int i = 0; i < geometry.numberOfChannels; ++i )
               if ( data[i] != nullptr )
                  allocator.Deallocate( data[i] ), data[i] = nullptr;
            allocator.Deallocate( data );
            Reset();
            UpdateSharedImage();
         }
      }
 
      Data* Clone( GenericImage* image ) const
      {
         Data* clone = nullptr;
         try
         {
            clone = new Data;
 
            if ( !IsEmpty() )
            {
               clone->data = clone->allocator.AllocateChannelSlots( geometry.numberOfChannels );
               for ( int i = 0; i < geometry.numberOfChannels; ++i )
               {
                  clone->data[i] = clone->allocator.AllocatePixels( geometry.width, geometry.height );
                  P::Copy( clone->data[i], data[i], geometry.NumberOfPixels() );
               }
 
               clone->geometry.Assign( geometry );
               clone->color.Assign( color );
            }
 
            clone->LinkWithClientImage( image );
            return clone;
         }
         catch ( ... )
         {
            if ( clone != nullptr )
            {
               clone->Deallocate();
               delete clone;
            }
            throw;
         }
      }
 
      void Reset()
      {
         data = nullptr;
         geometry.Reset();
         color.Reset();
      }
 
      void UpdateSharedImage()
      {
         allocator.SetSharedData( data );
         allocator.SetSharedGeometry( geometry.width, geometry.height, geometry.numberOfChannels );
         allocator.SetSharedColor( color.colorSpace, color.RGBWS );
      }
 
      void SynchronizeWithSharedImage()
      {
         data = allocator.GetSharedData();
         allocator.GetSharedGeometry( geometry.width, geometry.height, geometry.numberOfChannels );
         allocator.GetSharedColor( color.colorSpace, color.RGBWS );
      }
 
   private:
 
      Data() = default;
 
      void LinkWithClientImage( GenericImage* image )
      {
         if ( image != nullptr )
         {
            image->m_geometry = &geometry;
            image->m_color = &color;
         }
      }
   };
 
   Data* m_data = nullptr;
 
   void DetachFromData()
   {
      if ( !m_data->Detach() )
         delete m_data;
   }
 
   // -------------------------------------------------------------------------
 
   class RectThreadBase : public Thread
   {
   public:
 
      RectThreadBase( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : m_image( image )
         , m_rect( rect )
         , m_ch1( ch1 )
         , m_ch2( ch2 )
         , m_firstRow( firstRow )
         , m_endRow( endRow )
      {
      }
 
      virtual void Run() = 0;
 
   protected:
 
      const GenericImage& m_image;
      const Rect&         m_rect;
            int           m_ch1, m_ch2;
            int           m_firstRow, m_endRow;
 
      bool HasSimpleSelection() const
      {
         return m_rect.Width() == m_image.Width()
               && !m_image.IsLowRangeClippingEnabled()
               && !m_image.IsHighRangeClippingEnabled();
      }
 
      template <class F> void Execute( F process ) noexcept
      {
         int w = m_rect.Width();
         int dw = m_image.Width() - w;
 
         if ( dw == 0 )
         {
            size_type n = size_type( m_endRow - m_firstRow ) * size_type( w );
 
            if ( m_image.IsLowRangeClippingEnabled() )
            {
               sample clipLow = P::ToSample( m_image.RangeClipLow() );
               if ( m_image.IsHighRangeClippingEnabled() )
               {
                  sample clipHigh = P::ToSample( m_image.RangeClipHigh() );
                  for ( int i = m_ch1; i <= m_ch2; ++i )
                  {
                     const sample* __restrict__ f = m_image.PixelAddress( 0, m_rect.y0+m_firstRow, i );
                     PCL_IVDEP
                     for ( size_type j = 0; j < n; ++j, ++f )
                        if ( clipLow < *f )
                           if ( *f < clipHigh )
                              process( f );
                  }
               }
               else
               {
                  for ( int i = m_ch1; i <= m_ch2; ++i )
                  {
                     const sample* __restrict__ f = m_image.PixelAddress( 0, m_rect.y0+m_firstRow, i );
                     PCL_IVDEP
                     for ( size_type j = 0; j < n; ++j, ++f )
                        if ( clipLow < *f )
                           process( f );
                  }
               }
            }
            else if ( m_image.IsHighRangeClippingEnabled() )
            {
               sample clipHigh = P::ToSample( m_image.RangeClipHigh() );
               for ( int i = m_ch1; i <= m_ch2; ++i )
               {
                  const sample* __restrict__ f = m_image.PixelAddress( 0, m_rect.y0+m_firstRow, i );
                  PCL_IVDEP
                  for ( size_type j = 0; j < n; ++j, ++f )
                     if ( *f < clipHigh )
                        process( f );
               }
            }
            else
            {
               // Simple selection
               for ( int i = m_ch1; i <= m_ch2; ++i )
               {
                  const sample* __restrict__ f = m_image.PixelAddress( 0, m_rect.y0+m_firstRow, i );
                  PCL_IVDEP
                  for ( size_type j = 0; j < n; ++j, ++f )
                     process( f );
               }
            }
         }
         else
         {
            if ( m_image.IsLowRangeClippingEnabled() )
            {
               sample clipLow = P::ToSample( m_image.RangeClipLow() );
               if ( m_image.IsHighRangeClippingEnabled() )
               {
                  sample clipHigh = P::ToSample( m_image.RangeClipHigh() );
                  for ( int i = m_ch1; i <= m_ch2; ++i )
                  {
                     const sample* __restrict__ f = m_image.PixelAddress( m_rect.x0, m_rect.y0+m_firstRow, i );
                     for ( int j = m_firstRow; j < m_endRow; ++j, f += dw )
                     {
                        PCL_IVDEP
                        for ( int k = 0; k < w; ++k, ++f )
                           if ( clipLow < *f )
                              if ( *f < clipHigh )
                                 process( f );
                     }
                  }
               }
               else
               {
                  for ( int i = m_ch1; i <= m_ch2; ++i )
                  {
                     const sample* __restrict__ f = m_image.PixelAddress( m_rect.x0, m_rect.y0+m_firstRow, i );
                     for ( int j = m_firstRow; j < m_endRow; ++j, f += dw )
                     {
                        PCL_IVDEP
                        for ( int k = 0; k < w; ++k, ++f )
                           if ( clipLow < *f )
                              process( f );
                     }
                  }
               }
            }
            else if ( m_image.IsHighRangeClippingEnabled() )
            {
               sample clipHigh = P::ToSample( m_image.RangeClipHigh() );
               for ( int i = m_ch1; i <= m_ch2; ++i )
               {
                  const sample* __restrict__ f = m_image.PixelAddress( m_rect.x0, m_rect.y0+m_firstRow, i );
                  for ( int j = m_firstRow; j < m_endRow; ++j, f += dw )
                  {
                     PCL_IVDEP
                     for ( int k = 0; k < w; ++k, ++f )
                        if ( *f < clipHigh )
                           process( f );
                  }
               }
            }
            else
            {
               for ( int i = m_ch1; i <= m_ch2; ++i )
               {
                  const sample* __restrict__ f = m_image.PixelAddress( m_rect.x0, m_rect.y0+m_firstRow, i );
                  for ( int j = m_firstRow; j < m_endRow; ++j, f += dw )
                  {
                     PCL_IVDEP
                     for ( int k = 0; k < w; ++k, ++f )
                        process( f );
                  }
               }
            }
         }
      }
   };
 
   // -------------------------------------------------------------------------
 
   class CountThread : public RectThreadBase
   {
   public:
 
      size_type count = 0;
 
      CountThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
      void Run() final
      {
         /*
          * N.B. These threads are only used when range clipping is enabled.
          */
         int w = this->m_rect.Width();
         int dw = this->m_image.Width() - w;
 
         if ( this->m_image.IsLowRangeClippingEnabled() )
         {
            sample clipLow = P::ToSample( this->m_image.RangeClipLow() );
            if ( this->m_image.IsHighRangeClippingEnabled() )
            {
               sample clipHigh = P::ToSample( this->m_image.RangeClipHigh() );
               for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
               {
                  const sample* __restrict__ f = this->m_image.PixelAddress( this->m_rect.x0, this->m_rect.y0+this->m_firstRow, i );
                  for ( int j = this->m_firstRow; j < this->m_endRow; ++j, f += dw )
                  {
                     PCL_IVDEP
                     for ( int k = 0; k < w; ++k, ++f )
                        if ( clipLow < *f )
                           if ( *f < clipHigh )
                              ++count;
                  }
               }
            }
            else
            {
               for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
               {
                  const sample* __restrict__ f = this->m_image.PixelAddress( this->m_rect.x0, this->m_rect.y0+this->m_firstRow, i );
                  for ( int j = this->m_firstRow; j < this->m_endRow; ++j, f += dw )
                  {
                     PCL_IVDEP
                     for ( int k = 0; k < w; ++k, ++f )
                        if ( clipLow < *f )
                           ++count;
                  }
               }
            }
         }
         else if ( this->m_image.IsHighRangeClippingEnabled() )
         {
            sample clipHigh = P::ToSample( this->m_image.RangeClipHigh() );
            for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
            {
               const sample* __restrict__ f = this->m_image.PixelAddress( this->m_rect.x0, this->m_rect.y0+this->m_firstRow, i );
               for ( int j = this->m_firstRow; j < this->m_endRow; ++j, f += dw )
               {
                  PCL_IVDEP
                  for ( int k = 0; k < w; ++k, ++f )
                     if ( *f < clipHigh )
                        ++count;
               }
            }
         }
         else // ?! this should not happen
            count = size_type( 1 + this->m_ch2 - this->m_ch1 ) * size_type( w ) * size_type( this->m_rect.Height() );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class MinThread : public RectThreadBase
   {
   public:
 
      sample min;
      size_type count = 0;
 
      MinThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
      void Run() final
      {
         min = P::HighestSampleValue();
         count = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               if ( *f < min )
                  min = *f;
               ++count;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class MaxThread : public RectThreadBase
   {
   public:
 
      sample max;
      size_type count = 0;
 
      MaxThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
      void Run() final
      {
         max = P::LowestSampleValue();
         count = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               if ( max < *f )
                  max = *f;
               ++count;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class MinMaxThread : public RectThreadBase
   {
   public:
 
      sample min;
      sample max;
      size_type count = 0;
 
      MinMaxThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
      void Run() final
      {
         min = P::HighestSampleValue();
         max = P::LowestSampleValue();
         count = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               if ( *f < min )
                  min = *f;
               if ( max < *f )
                  max = *f;
               ++count;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class ExtremePosThreadBase : public RectThreadBase
   {
   public:
 
      int cmin, cmax;
      Point pmin, pmax;
      size_type count = 0;
 
      ExtremePosThreadBase( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
      void Run() final
      {
         count = 0;
         m_amin = m_amax = nullptr;
         DoExecute();
 
         if ( count > 0 )
         {
            if ( m_amin != nullptr )
               for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
                  if ( m_amin >= this->m_image[i] && m_amin < (this->m_image[i] + this->m_image.NumberOfPixels()) )
                  {
                     cmin = i;
                     pmin.x = (m_amin - this->m_image[i]) % this->m_image.Width();
                     pmin.y = (m_amin - this->m_image[i]) / this->m_image.Width();
                     break;
                  }
            if ( m_amax != nullptr )
               for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
                  if ( m_amax >= this->m_image[i] && m_amax < (this->m_image[i] + this->m_image.NumberOfPixels()) )
                  {
                     cmax = i;
                     pmax.x = (m_amax - this->m_image[i]) % this->m_image.Width();
                     pmax.y = (m_amax - this->m_image[i]) / this->m_image.Width();
                     break;
                  }
         }
      }
 
   protected:
 
      const sample* m_amin;
      const sample* m_amax;
 
      virtual void DoExecute() = 0;
   };
 
   // -------------------------------------------------------------------------
 
   class MinPosThread : public ExtremePosThreadBase
   {
   public:
 
      sample min;
 
      MinPosThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : ExtremePosThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
   private:
 
      void DoExecute() override
      {
         min = P::HighestSampleValue();
         this->Execute( [=]( const sample* __restrict__ f )
            {
               if ( *f < min )
                  min = *(this->m_amin = f);
               ++this->count;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class MaxPosThread : public ExtremePosThreadBase
   {
   public:
 
      sample max;
 
      MaxPosThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : ExtremePosThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
   private:
 
      void DoExecute() override
      {
         max = P::LowestSampleValue();
         this->Execute( [=]( const sample* __restrict__ f )
            {
               if ( max < *f )
                  max = *(this->m_amax = f);
               ++this->count;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class MinMaxPosThread : public ExtremePosThreadBase
   {
   public:
 
      sample min, max;
 
      MinMaxPosThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : ExtremePosThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
   private:
 
      void DoExecute() override
      {
         min = P::HighestSampleValue();
         max = P::LowestSampleValue();
         this->Execute( [=]( const sample* __restrict__ f )
            {
               if ( *f < min )
                  min = *(this->m_amin = f);
               if ( max < *f )
                  max = *(this->m_amax = f);
               ++this->count;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class SumThread : public RectThreadBase
   {
   public:
 
      double s = 0;
      size_type n = 0;
 
      SumThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
      void Run() final
      {
         s = e = 0;
         n = 0;
         DoExecute();
      }
 
   protected:
 
      double e = 0;
 
      void SumStep( double x ) noexcept
      {
         double y = x - e;
         double t = s + y;
         e = (t - s) - y;
         s = t;
         ++n;
      }
 
      virtual void DoExecute()
      {
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double v; P::FromSample( v, *f );
               SumStep( v );
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class SumSqrThread : public SumThread
   {
   public:
 
      SumSqrThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : SumThread( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
   private:
 
      void DoExecute() override
      {
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double v; P::FromSample( v, *f );
               this->SumStep( v*v );
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class SumAbsThread : public SumThread
   {
   public:
 
      SumAbsThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : SumThread( image, rect, ch1, ch2, firstRow, endRow )
      {
      }
 
   private:
 
      void DoExecute() override
      {
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double v; P::FromSample( v, *f );
               this->SumStep( pcl::Abs( v ) );
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class NormThread : public RectThreadBase
   {
   public:
 
      Vector R;
      size_type n = 0;
 
      NormThread( const GenericImage& image, int degree, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , R( degree )
         , e( degree )
      {
      }
 
      void Run() final
      {
         R = e = 0.0;
         n = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double v; P::FromSample( v, *f );
               for ( int i = 0;; )
               {
                  NormStep( i, v );
                  if ( ++i == R.Length() )
                     break;
                  v *= v;
               }
               ++n;
            } );
      }
 
   protected:
 
      Vector e;
 
      void NormStep( int i, double x ) noexcept
      {
         double y = x - e[i];
         double t = R[i] + y;
         e[i] = (t - R[i]) - y;
         R[i] = t;
      }
   };
 
   // -------------------------------------------------------------------------
 
   class HistogramThread : public RectThreadBase
   {
   public:
 
      SzVector H;
 
      HistogramThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow,
                       const double& low, const double& high )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , H( __PCL_MEDIAN_HISTOGRAM_LENGTH )
         , m_low( low )
         , m_high( high )
      {
      }
 
      void Run() final
      {
         H = size_type( 0 );
 
         if ( this->HasSimpleSelection() )
         {
            size_type n = size_type( this->m_endRow - this->m_firstRow ) * size_type( this->m_rect.Width() );
            for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
               Build( H, this->m_image.PixelAddress( 0, this->m_rect.y0+this->m_firstRow, i ), n, m_low, m_high );
         }
         else
         {
            m_range = m_high - m_low;
            if ( 1 + m_range != 1 )
            {
               const double scale = (__PCL_MEDIAN_HISTOGRAM_LENGTH - 1)/m_range;
               this->Execute( [=]( const sample* __restrict__ f )
                  {
                     const int k = TruncInt( scale*(*f - m_low) );
                     if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                        ++H[k];
                  } );
            }
         }
      }
 
   private:
 
      const double& m_low;
      const double& m_high;
      double        m_range;
 
      template <typename T1>
      static void Build( SzVector& H, const T1* __restrict__ A, size_type N, double low, double high )
      {
         const double range = high - low;
         if ( 1 + range != 1 )
         {
            const double scale = (__PCL_MEDIAN_HISTOGRAM_LENGTH - 1)/range;
            PCL_IVDEP
            for ( size_type i = 0; i < N; ++i )
            {
               const int k = TruncInt( scale*(A[i] - low) );
               if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                  ++H[k];
            }
         }
      }
 
#ifdef __PCL_AVX2
 
      PCL_HOT_FUNCTION
      static void Build( SzVector& H, const float* __restrict__ A, size_type N, double low, double high )
      {
         const double range = high - low;
         if ( 1 + range == 1 )
            return;
 
         const float s = float( (__PCL_MEDIAN_HISTOGRAM_LENGTH - 1)/range );
         const float l = float( low );
         const __m256 S = _mm256_set1_ps( s );
         const __m256 L = _mm256_set1_ps( l );
         const size_type stepLength = 0x40000000u;
 
         for ( size_type p = 0; p < N; p += stepLength )
         {
            const float* __restrict__ V = A + p;
            const int n = int( pcl::Min( stepLength, N - p ) );
            const int n8 = n >> 3;
 
            if ( ((ptrdiff_t)V) & 31 )
               for ( int i = 0; i < n8; ++i )
               {
                  __m256 v = _mm256_loadu_ps( (const float* __restrict__)(V + i*8) );
                  __m256i K = _mm256_cvttps_epi32( _mm256_mul_ps( _mm256_sub_ps( v, L ), S ) );
                  for ( int j = 0; j < 8; ++j )
                  {
                     const int k = ((const int* __restrict__)&K)[j];
                     if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                        ++H[k];
                  }
               }
            else
               for ( int i = 0; i < n8; ++i )
               {
                  __m256i K = _mm256_cvttps_epi32( _mm256_mul_ps( _mm256_sub_ps( ((const __m256* __restrict__)V)[i], L ), S ) );
                  for ( int j = 0; j < 8; ++j )
                  {
                     const int k = ((const int* __restrict__)&K)[j];
                     if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                        ++H[k];
                  }
               }
 
            for ( int i = n8 << 3; i < n; ++i )
            {
               const int k = TruncInt( s * (V[i] - l) );
               if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                  ++H[k];
            }
         }
      }
 
      PCL_HOT_FUNCTION
      static void Build( SzVector& H, const double* __restrict__ A, size_type N, double low, double high )
      {
         const double range = high - low;
         if ( 1 + range == 1 )
            return;
 
         const double s = (__PCL_MEDIAN_HISTOGRAM_LENGTH - 1)/range;
         const __m256d S = _mm256_set1_pd( s );
         const __m256d L = _mm256_set1_pd( low );
         const size_type stepLength = 0x40000000u;
 
         for ( size_type p = 0; p < N; p += stepLength )
         {
            const double* __restrict__ V = A + p;
            const int n = int( pcl::Min( stepLength, N - p ) );
            const int n4 = n >> 2;
 
            if ( ((ptrdiff_t)V) & 31 )
               for ( int i = 0; i < n4; ++i )
               {
                  __m256d v = _mm256_loadu_pd( (const double* __restrict__)(V + i*4) );
                  __m128i K = _mm256_cvttpd_epi32( _mm256_mul_pd( _mm256_sub_pd( v, L ), S ) );
                  for ( int j = 0; j < 4; ++j )
                  {
                     const int k = ((const int* __restrict__)&K)[j];
                     if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                        ++H[k];
                  }
               }
            else
               for ( int i = 0; i < n4; ++i )
               {
                  __m128i K = _mm256_cvttpd_epi32( _mm256_mul_pd( _mm256_sub_pd( ((const __m256d* __restrict__)V)[i], L ), S ) );
                  for ( int j = 0; j < 4; ++j )
                  {
                     const int k = ((const int* __restrict__)&K)[j];
                     if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                        ++H[k];
                  }
               }
 
            for ( int i = n4 << 2; i < n; ++i )
            {
               const int k = TruncInt( s * (V[i] - low) );
               if ( k >= 0 && k < __PCL_MEDIAN_HISTOGRAM_LENGTH )
                  ++H[k];
            }
         }
      }
 
#endif // __PCL_AVX2
   };
 
   // -------------------------------------------------------------------------
 
   class ExtremeAbsDevThread : public RectThreadBase
   {
   public:
 
      double minAbsDev = 0, maxAbsDev = 0;
      size_type count = 0;
 
      ExtremeAbsDevThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow, double center )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
      {
      }
 
      void Run() final
      {
         minAbsDev = std::numeric_limits<double>::max();
         maxAbsDev = 0;
         count = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double d; P::FromSample( d, *f );
               d = pcl::Abs( d - m_center );
               if ( d < minAbsDev )
                  minAbsDev = d;
               if ( d > maxAbsDev )
                  maxAbsDev = d;
               ++count;
            } );
      }
 
   private:
 
      double m_center;
   };
 
   // -------------------------------------------------------------------------
 
   class TwoSidedExtremeAbsDevThread : public RectThreadBase
   {
   public:
 
      double minAbsDevLow = 0, minAbsDevHigh = 0;
      double maxAbsDevLow = 0, maxAbsDevHigh = 0;
      size_type nLow = 0, nHigh = 0;
 
      TwoSidedExtremeAbsDevThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow, double center )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
      {
      }
 
      void Run() final
      {
         minAbsDevLow = minAbsDevHigh = std::numeric_limits<double>::max();
         maxAbsDevLow = maxAbsDevHigh = 0;
         nLow = nHigh = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double x; P::FromSample( x, *f );
               if ( x <= m_center )
               {
                  double d = m_center - x;
                  if ( d < minAbsDevLow )
                     minAbsDevLow = d;
                  if ( d > maxAbsDevLow )
                     maxAbsDevLow = d;
                  ++nLow;
               }
               else
               {
                  double d = x - m_center;
                  if ( d < minAbsDevHigh )
                     minAbsDevHigh = d;
                  if ( d > maxAbsDevHigh )
                     maxAbsDevHigh = d;
                  ++nHigh;
               }
            } );
      }
 
   private:
 
      double m_center;
   };
 
   // -------------------------------------------------------------------------
 
   class AbsDevHistogramThread : public RectThreadBase
   {
   public:
 
      SzVector H;
 
      AbsDevHistogramThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow,
                             double center, const double& low, const double& high )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , H( __PCL_MEDIAN_HISTOGRAM_LENGTH )
         , m_center( center )
         , m_low( low )
         , m_high( high )
      {
      }
 
      void Run() final
      {
         H = size_type( 0 );
         m_range = m_high - m_low;
// Workaround for clang compiler bug on macOS:
// https://pixinsight.com/forum/index.php?threads/pi-always-crash-when-stf.15830/
#ifdef __PCL_MACOSX
         if ( 1 + m_range != 1 )
#endif
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double d; P::FromSample( d, *f );
               d = pcl::Abs( d - m_center );
               if ( d >= m_low )
                  if ( d <= m_high )
                     ++H[TruncInt( (__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) * (d - m_low)/m_range )];
            } );
      }
 
   private:
 
      double        m_center;
      const double& m_low;
      const double& m_high;
      double        m_range;
   };
 
   // -------------------------------------------------------------------------
 
   class TwoSidedAbsDevHistogramThread : public RectThreadBase
   {
   public:
 
      SzVector H;
 
      TwoSidedAbsDevHistogramThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow,
                                     double center, const int& side, const double& low, const double& high )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , H( __PCL_MEDIAN_HISTOGRAM_LENGTH )
         , m_center( center )
         , m_side( side )
         , m_low( low )
         , m_high( high )
      {
      }
 
      void Run() final
      {
         H = size_type( 0 );
         m_range = m_high - m_low;
// Workaround for clang compiler bug on macOS:
// https://pixinsight.com/forum/index.php?threads/pi-always-crash-when-stf.15830/
#ifdef __PCL_MACOSX
         if ( 1 + m_range != 1 )
#endif
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double x; P::FromSample( x, *f );
               if ( m_side > 0 == x > m_center )
               {
                  double d = m_side ? x - m_center : m_center - x;
                  if ( d >= m_low )
                     if ( d <= m_high )
                        ++H[TruncInt( (__PCL_MEDIAN_HISTOGRAM_LENGTH - 1) * (d - m_low)/m_range )];
               }
            } );
      }
 
   private:
 
      double        m_center;
      const int&    m_side;
      const double& m_low;
      const double& m_high;
      double        m_range;
   };
 
   // -------------------------------------------------------------------------
 
   class VarThread : public RectThreadBase
   {
   public:
 
      double var = 0, eps = 0;
 
      VarThread( const GenericImage& image, double mean, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , m_mean( mean )
      {
      }
 
      void Run() final
      {
         var = eps = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double d; P::FromSample( d, *f );
               d -= m_mean;
               var += d*d;
               eps += d;
            } );
      }
 
   private:
 
      double m_mean;
   };
 
   // -------------------------------------------------------------------------
 
   class SumAbsDevThread : public SumThread
   {
   public:
 
      SumAbsDevThread( const GenericImage& image, double center, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : SumThread( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
      {
      }
 
   private:
 
      double m_center;
 
      void DoExecute() override
      {
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double v; P::FromSample( v, *f );
               this->SumStep( pcl::Abs( v - m_center ) );
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class TwoSidedSumAbsDevThread : public RectThreadBase
   {
   public:
 
      double s0 = 0, s1 = 0;
      size_type n0 = 0, n1 = 0;
 
      TwoSidedSumAbsDevThread( const GenericImage& image, double center,
                               const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
      {
      }
 
      void Run() final
      {
         s0 = s1 = 0;
         n0 = n1 = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double v; P::FromSample( v, *f );
               if ( v <= m_center )
               {
                  s0 += m_center - v;
                  ++n0;
               }
               else
               {
                  s1 += v - m_center;
                  ++n1;
               }
            } );
      }
 
   private:
 
      double m_center;
   };
 
   // -------------------------------------------------------------------------
 
   class BWMVThread : public RectThreadBase
   {
   public:
 
      double num = 0, den = 0;
      size_type n = 0, nr = 0;
 
      BWMVThread( const GenericImage& image, double center, double kd,
                  const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
         , m_kd( kd )
      {
      }
 
      void Run() final
      {
         num = den = 0;
         n = nr = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               ++n;
               double xc; P::FromSample( xc, *f ); xc -= m_center;
               double y = xc/m_kd;
               if ( pcl::Abs( y ) < 1 )
               {
                  double y2 = y*y;
                  double y21 = 1 - y2;
                  num += xc*xc * y21*y21*y21*y21;
                  den += y21 * (1 - 5*y2);
                  ++nr;
               }
            } );
      }
 
   private:
 
      double m_center;
      double m_kd;
   };
 
   // -------------------------------------------------------------------------
 
   class TwoSidedBWMVThread : public RectThreadBase
   {
   public:
 
      double num0 = 0, den0 = 0;
      double num1 = 0, den1 = 0;
      size_type n0 = 0, n1 = 0, nr0 = 0, nr1 = 0;
 
      TwoSidedBWMVThread( const GenericImage& image, double center, double kd0, double kd1,
                          const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
         , m_kd0( kd0 )
         , m_kd1( kd1 )
      {
      }
 
      void Run() final
      {
         num0 = den0 = num1 = den1 = 0;
         n0 = n1 = nr0 = nr1 = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double xc; P::FromSample( xc, *f ); xc -= m_center;
               bool low = xc <= 0;
               if ( low )
                  ++n0;
               else
                  ++n1;
 
               double y = xc/(low ? m_kd0 : m_kd1);
               if ( pcl::Abs( y ) < 1 )
               {
                  double y2 = y*y;
                  double y21 = 1 - y2;
                  double num = xc*xc * y21*y21*y21*y21;
                  double den = y21 * (1 - 5*y2);
                  if ( low )
                  {
                     num0 += num;
                     den0 += den;
                     ++nr0;
                  }
                  else
                  {
                     num1 += num;
                     den1 += den;
                     ++nr1;
                  }
               }
            } );
      }
 
   private:
 
      double m_center;
      double m_kd0;
      double m_kd1;
   };
 
   // -------------------------------------------------------------------------
 
   class SmpThread : public RectThreadBase
   {
   public:
 
      Array<sample> samples;
      size_type n = 0;
 
      SmpThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
         size_type N = size_type( this->m_rect.Width() )
                     * size_type( this->m_endRow - this->m_firstRow )
                     * (1 + this->m_ch2 - this->m_ch1);
         samples = Array<sample>( N );
      }
 
      void Run() final
      {
         n = 0;
         this->Execute( [=]( const sample* __restrict__ f )
            {
               samples[n++] = *f;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class DSmpThread : public RectThreadBase
   {
   public:
 
      Array<double> values;
      size_type n = 0;
 
      DSmpThread( const GenericImage& image, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : RectThreadBase( image, rect, ch1, ch2, firstRow, endRow )
      {
         size_type N = size_type( this->m_rect.Width() )
                     * size_type( this->m_endRow - this->m_firstRow )
                     * (1 + this->m_ch2 - this->m_ch1);
         values = Array<double>( N );
      }
 
      void Run() final
      {
         n = 0;
         DoExecute();
      }
 
   protected:
 
      virtual void DoExecute()
      {
         if ( this->HasSimpleSelection() )
         {
            size_type N = size_type( this->m_endRow - this->m_firstRow ) * size_type( this->m_rect.Width() );
            for ( int i = this->m_ch1; i <= this->m_ch2; ++i )
            {
               const sample* __restrict__ f = this->m_image.PixelAddress( 0, this->m_rect.y0 + this->m_firstRow, i );
               PCL_IVDEP
               for ( size_type j = 0; j < N; ++j, ++n, ++f )
                  P::FromSample( values[n], *f );
            }
         }
         else
         {
            this->Execute( [=]( const sample* __restrict__ f )
               {
                  P::FromSample( values[n++], *f );
               } );
         }
      }
   };
 
   // -------------------------------------------------------------------------
 
   class AbsDevSmpThread : public DSmpThread
   {
   public:
 
      AbsDevSmpThread( const GenericImage& image, double center, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : DSmpThread( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
      {
      }
 
   private:
 
      double m_center;
 
      void DoExecute() override
      {
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double d; P::FromSample( d, *f );
               this->values[this->n++] = pcl::Abs( d - m_center );
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class TwoSidedAbsDevSmpThread : public DSmpThread
   {
   public:
 
      Array<double>::iterator p, q;
 
      TwoSidedAbsDevSmpThread( const GenericImage& image, double center, const Rect& rect, int ch1, int ch2, int firstRow, int endRow )
         : DSmpThread( image, rect, ch1, ch2, firstRow, endRow )
         , m_center( center )
      {
      }
 
   private:
 
      double m_center;
 
      void DoExecute() override
      {
         p = this->values.Begin();
         q = this->values.End();
         this->Execute( [=]( const sample* __restrict__ f )
            {
               double x; P::FromSample( x, *f );
               if ( x <= m_center )
                  *p++ = m_center - x;
               else
                  *--q = x - m_center;
               ++this->n;
            } );
      }
   };
 
   // -------------------------------------------------------------------------
 
   class ColorSpaceConversionThread : public Thread
   {
   public:
 
      ColorSpaceConversionThread( GenericImage& image, ThreadData& data,
                                  color_space toColorSpace, size_type begin, size_type end )
         : m_image( image )
         , m_data( data )
         , m_toColorSpace( toColorSpace )
         , m_begin( begin )
         , m_end( end )
      {
      }
 
      void Run() final
      {
         INIT_THREAD_MONITOR()
 
         const RGBColorSystem& rgbws = m_image.RGBWorkingSpace();
 
         typename P::sample* f0 = m_image[0] + m_begin;
         typename P::sample* f1 = m_image[1] + m_begin;
         typename P::sample* f2 = m_image[2] + m_begin;
         typename P::sample* fN = m_image[0] + m_end;
 
         for ( ; f0 < fN; ++f0, ++f1, ++f2 )
         {
            RGBColorSystem::sample r0, r1, r2;
            P::FromSample( r0, *f0 );
            P::FromSample( r1, *f1 );
            P::FromSample( r2, *f2 );
 
            switch ( m_image.ColorSpace() )
            {
            case ColorSpace::RGB :
               switch ( m_toColorSpace )
               {
               case ColorSpace::Gray :
                  rgbws.RGBToGray( r0, r0, r1, r2 );
                  break;
               case ColorSpace::HSV :
                  rgbws.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSI :
                  rgbws.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIEXYZ :
                  rgbws.RGBToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELab :
                  rgbws.RGBToCIELab( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELch :
                  rgbws.RGBToCIELch( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
               break;
            case ColorSpace::HSV :
               rgbws.HSVToRGB( r0, r1, r2, r0, r1, r2 );
               switch ( m_toColorSpace )
               {
               case ColorSpace::Gray :
                  rgbws.RGBToGray( r0, r0, r1, r2 );
                  break;
               case ColorSpace::RGB :
                  break;
               case ColorSpace::HSI :
                  rgbws.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIEXYZ :
                  rgbws.RGBToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELab :
                  rgbws.RGBToCIELab( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELch :
                  rgbws.RGBToCIELch( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
               break;
            case ColorSpace::HSI :
               rgbws.HSIToRGB( r0, r1, r2, r0, r1, r2 );
               switch ( m_toColorSpace )
               {
               case ColorSpace::Gray :
                  rgbws.RGBToGray( r0, r0, r1, r2 );
                  break;
               case ColorSpace::RGB :
                  break;
               case ColorSpace::HSV :
                  rgbws.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIEXYZ :
                  rgbws.RGBToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELab :
                  rgbws.RGBToCIELab( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELch :
                  rgbws.RGBToCIELch( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
               break;
            case ColorSpace::CIEXYZ :
               switch ( m_toColorSpace )
               {
               case ColorSpace::Gray :
                  rgbws.CIEXYZToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToGray( r0, r0, r1, r2 );
                  break;
               case ColorSpace::RGB :
                  rgbws.CIEXYZToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSV :
                  rgbws.CIEXYZToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSI :
                  rgbws.CIEXYZToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELab :
                  rgbws.CIEXYZToCIELab( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELch :
                  rgbws.CIEXYZToCIELab( r0, r1, r2, r0, r1, r2 );
                  rgbws.CIELabToCIELch( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
               break;
            case ColorSpace::CIELab :
               switch ( m_toColorSpace )
               {
               case ColorSpace::Gray :
                  rgbws.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToGray( r0, r0, r1, r2 );
                  break;
               case ColorSpace::RGB :
                  rgbws.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSV :
                  rgbws.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSI :
                  rgbws.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIEXYZ :
                  rgbws.CIELabToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELch :
                  rgbws.CIELabToCIELch( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
               break;
            case ColorSpace::CIELch :
               switch ( m_toColorSpace )
               {
               case ColorSpace::Gray :
                  rgbws.CIELchToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToGray( r0, r0, r1, r2 );
                  break;
               case ColorSpace::RGB :
                  rgbws.CIELchToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSV :
                  rgbws.CIELchToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::HSI :
                  rgbws.CIELchToRGB( r0, r1, r2, r0, r1, r2 );
                  rgbws.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIEXYZ :
                  rgbws.CIELchToCIELab( r0, r1, r2, r0, r1, r2 );
                  rgbws.CIELabToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELab :
                  rgbws.CIELchToCIELab( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
               break;
            default:
               break;
            }
 
            *f0 = P::ToSample( r0 );
 
            if ( m_toColorSpace != ColorSpace::Gray )
            {
               *f1 = P::ToSample( r1 );
               *f2 = P::ToSample( r2 );
            }
 
            UPDATE_THREAD_MONITOR( 65536 )
         }
      }
 
   private:
 
      GenericImage& m_image;
      ThreadData&   m_data;
      color_space   m_toColorSpace;
      size_type     m_begin, m_end;
   };
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   class GetLuminanceThread : public Thread
   {
   public:
 
      GetLuminanceThread( GenericImage<P1>& luminance, const GenericImage& image, ThreadData& data,
                          const Rect& rect, int firstRow, int endRow )
         : m_luminance( luminance )
         , m_image( image )
         , m_data( data )
         , m_rect( rect )
         , m_firstRow( firstRow )
         , m_endRow( endRow )
      {
      }
 
      void Run() final
      {
         INIT_THREAD_MONITOR()
 
         const RGBColorSystem& rgbws = m_image.RGBWorkingSpace();
 
         const typename P::sample* f0 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 0 );
         const typename P::sample* f1 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 1 );
         const typename P::sample* f2 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 2 );
 
         typename P1::sample* fY = m_luminance.ScanLine( m_firstRow );
 
         for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width();
               y < m_endRow;
               ++y, f0 += dw, f1 += dw, f2 += dw )
         {
            const typename P::sample* fN = f0 + m_rect.Width();
 
            for ( ; f0 < fN; ++f0, ++f1, ++f2, ++fY )
            {
               RGBColorSystem::sample r0, r1, r2, rY;
               P::FromSample( r0, *f0 );
               P::FromSample( r1, *f1 );
               P::FromSample( r2, *f2 );
 
               switch ( m_image.ColorSpace() )
               {
               case ColorSpace::RGB:
               case ColorSpace::HSV:
               case ColorSpace::HSI:
                  switch ( m_image.ColorSpace() )
                  {
                  case ColorSpace::HSV:
                     rgbws.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                     break;
                  case ColorSpace::HSI:
                     rgbws.HSIToRGB( r0, r1, r2, r0, r1, r2 );
                     break;
                  default:
                     break;
                  }
                  rY = rgbws.CIEY( r0, r1, r2 );
                  break;
 
               case ColorSpace::CIELch:
                  rgbws.CIELchToCIELab( r0, r1, r2, r0, r1, r2 );
                  // fall through
               case ColorSpace::CIELab:
                  rgbws.CIELabToCIEXYZ( r0, rY, r2, r0, r1, r2 );
                  break;
 
               default: // ?!
                  rY = 0;
                  break;
               }
 
               *fY = P1::ToSample( rY );
 
               UPDATE_THREAD_MONITOR( 65536 )
            }
         }
      }
 
   private:
 
            GenericImage<P1>& m_luminance;
      const GenericImage&     m_image;
            ThreadData&       m_data;
      const Rect&             m_rect;
            int               m_firstRow, m_endRow;
   };
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   class GetLightnessThread : public Thread
   {
   public:
 
      GetLightnessThread( GenericImage<P1>& lightness, const GenericImage& image, ThreadData& data,
                          const Rect& rect, int firstRow, int endRow )
         : m_lightness( lightness )
         , m_image( image )
         , m_data( data )
         , m_rect( rect )
         , m_firstRow( firstRow )
         , m_endRow( endRow )
      {
      }
 
      void Run() final
      {
         INIT_THREAD_MONITOR()
 
         const RGBColorSystem& rgbws = m_image.RGBWorkingSpace();
 
         const typename P::sample* f0 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 0 );
         const typename P::sample* f1 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 1 );
         const typename P::sample* f2 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 2 );
 
         typename P1::sample* fL = m_lightness.ScanLine( m_firstRow );
 
         for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width();
               y < m_endRow;
               ++y, f0 += dw, f1 += dw, f2 += dw )
         {
            const typename P::sample* fN = f0 + m_rect.Width();
 
            for ( ; f0 < fN; ++f0, ++f1, ++f2, ++fL )
            {
               RGBColorSystem::sample r0, r1, r2, rL;
               P::FromSample( r0, *f0 );
               P::FromSample( r1, *f1 );
               P::FromSample( r2, *f2 );
 
               switch ( m_image.ColorSpace() )
               {
               case ColorSpace::RGB:
               case ColorSpace::HSV:
               case ColorSpace::HSI:
               case ColorSpace::CIEXYZ:
                  switch ( m_image.ColorSpace() )
                  {
                  case ColorSpace::HSV:
                     rgbws.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                     break;
                  case ColorSpace::HSI:
                     rgbws.HSIToRGB( r0, r1, r2, r0, r1, r2 );
                     break;
                  case ColorSpace::CIEXYZ:
                     rgbws.CIEXYZToRGB( r0, r1, r2, r0, r1, r2 );
                     break;
                  default:
                     break;
                  }
                  rL = rgbws.CIEL( r0, r1, r2 );
                  break;
 
               default: // ?!
                  rL = 0;
                  break;
               }
 
               *fL = P1::ToSample( rL );
 
               UPDATE_THREAD_MONITOR( 65536 )
            }
         }
      }
 
   private:
 
            GenericImage<P1>& m_lightness;
      const GenericImage&     m_image;
            ThreadData&       m_data;
      const Rect&             m_rect;
            int               m_firstRow, m_endRow;
   };
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   class GetIntensityThread : public Thread
   {
   public:
 
      GetIntensityThread( GenericImage<P1>& luminance, const GenericImage& image, ThreadData& data,
                          const Rect& rect, int firstRow, int endRow )
         : m_intensity( luminance )
         , m_image( image )
         , m_data( data )
         , m_rect( rect )
         , m_firstRow( firstRow )
         , m_endRow( endRow )
      {
      }
 
      void Run() final
      {
         INIT_THREAD_MONITOR()
 
         const RGBColorSystem& rgbws = m_image.RGBWorkingSpace();
 
         const typename P::sample* f0 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 0 );
         const typename P::sample* f1 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 1 );
         const typename P::sample* f2 = m_image.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 2 );
 
         typename P1::sample* fI = m_intensity.ScanLine( m_firstRow );
 
         for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width();
               y < m_endRow;
               ++y, f0 += dw, f1 += dw, f2 += dw )
         {
            const typename P::sample* fN = f0 + m_rect.Width();
 
            for ( ; f0 < fN; ++f0, ++f1, ++f2, ++fI )
            {
               RGBColorSystem::sample r0, r1, r2;
               P::FromSample( r0, *f0 );
               P::FromSample( r1, *f1 );
               P::FromSample( r2, *f2 );
 
               switch ( m_image.ColorSpace() )
               {
               case ColorSpace::RGB:
                  break;
               case ColorSpace::HSV:
                  rgbws.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIEXYZ:
                  rgbws.CIEXYZToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELab:
                  rgbws.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               case ColorSpace::CIELch:
                  rgbws.CIELchToRGB( r0, r1, r2, r0, r1, r2 );
                  break;
               default:
                  break;
               }
 
               *fI = P1::ToSample( rgbws.Intensity( r0, r1, r2 ) );
 
               UPDATE_THREAD_MONITOR( 65536 )
            }
         }
      }
 
   private:
 
            GenericImage<P1>& m_intensity;
      const GenericImage&     m_image;
            ThreadData&       m_data;
      const Rect&             m_rect;
            int               m_firstRow, m_endRow;
   };
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   class SetLuminanceThread : public Thread
   {
   public:
 
      SetLuminanceThread( GenericImage& image, const GenericImage<P1>& luminance, ThreadData& data,
                          const Point& target, const Rect& rect, int firstRow, int endRow )
         : m_image( image )
         , m_luminance( luminance )
         , m_data( data )
         , m_target( target )
         , m_rect( rect )
         , m_firstRow( firstRow )
         , m_endRow( endRow )
      {
      }
 
      void Run() final
      {
         INIT_THREAD_MONITOR()
 
         const RGBColorSystem& sourceRGBWS = m_luminance.RGBWorkingSpace();
         const RGBColorSystem& targetRGBWS = m_image.RGBWorkingSpace();
 
         typename P::sample* f0 = m_image.PixelAddress( m_target.x, m_target.y + m_firstRow, 0 );
         typename P::sample* f1 = m_image.PixelAddress( m_target.x, m_target.y + m_firstRow, 1 );
         typename P::sample* f2 = m_image.PixelAddress( m_target.x, m_target.y + m_firstRow, 2 );
 
         if ( m_luminance.ColorSpace() == ColorSpace::Gray || m_luminance.ColorSpace() == ColorSpace::CIEXYZ )
         {
            int cY = (m_luminance.ColorSpace() == ColorSpace::Gray) ? 0 : 1;
            const typename P1::sample* fY = m_luminance.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, cY );
 
            for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width(), dwY = m_luminance.Width()-m_rect.Width();
                  y < m_endRow;
                  ++y, f0 += dw, f1 += dw, f2 += dw, fY += dwY )
            {
               const typename P::sample* fN = f0 + m_rect.Width();
 
               for ( ; f0 < fN; ++f0, ++f1, ++f2, ++fY )
               {
                  RGBColorSystem::sample r0, r1, r2, rY;
                  P::FromSample(  r0, *f0 );
                  P::FromSample(  r1, *f1 );
                  P::FromSample(  r2, *f2 );
                  P1::FromSample( rY, *fY );
 
                  switch ( m_image.ColorSpace() )
                  {
                  case ColorSpace::RGB:
                  case ColorSpace::HSV:
                  case ColorSpace::HSI:
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::HSV:
                        targetRGBWS.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::HSI:
                        targetRGBWS.HSIToRGB( r0, r1, r2, r0, r1, r2 );
                        break;
                     default: // RGB
                        break;
                     }
                     targetRGBWS.RGBToCIEab( r1, r2, r0, r1, r2 );
                     targetRGBWS.CIELabToRGB( r0, r1, r2, sourceRGBWS.CIEYToCIEL( rY ), r1, r2 );
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::HSV:
                        targetRGBWS.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::HSI:
                        targetRGBWS.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                        break;
                     default: // RGB
                        break;
                     }
                     break;
 
                  case ColorSpace::CIEXYZ:
                     targetRGBWS.CIEXYZToCIELab( r0, r1, r2, r0, r1, r2 );
                     targetRGBWS.CIELabToCIEXYZ( r0, r1, r2, sourceRGBWS.CIEYToCIEL( rY ), r1, r2 );
                     break;
 
                  case ColorSpace::CIELab:
                  case ColorSpace::CIELch:
                     r0 = sourceRGBWS.CIEYToCIEL( rY );
                     break;
 
                  default: // ???
                     break;
                  }
 
                  *f0 = P::ToSample( r0 );
                  *f1 = P::ToSample( r1 );
                  *f2 = P::ToSample( r2 );
 
                  UPDATE_THREAD_MONITOR( 65536 )
               }
            }
         }
         else
         {
            const typename P1::sample* g0 = m_luminance.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 0 );
            const typename P1::sample* g1 = m_luminance.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 1 );
            const typename P1::sample* g2 = m_luminance.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 2 );
 
            for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width(), dwY = m_luminance.Width()-m_rect.Width();
                  y < m_endRow;
                  ++y, f0 += dw, f1 += dw, f2 += dw, g0 += dwY, g1 += dwY, g2 += dwY )
            {
               const typename P::sample* fN = f0 + m_rect.Width();
 
               for ( ; f0 < fN; ++f0, ++f1, ++f2, ++g0, ++g1, ++g2 )
               {
                  typename RGBColorSystem::sample r0, r1, r2, s0, s1, s2;
                  P::FromSample(  r0, *f0 );
                  P::FromSample(  r1, *f1 );
                  P::FromSample(  r2, *f2 );
                  P1::FromSample( s0, *g0 );
                  P1::FromSample( s1, *g1 );
                  P1::FromSample( s2, *g2 );
 
                  switch ( m_image.ColorSpace() )
                  {
                  case ColorSpace::RGB:
                  case ColorSpace::HSV:
                  case ColorSpace::HSI:
                  case ColorSpace::CIEXYZ:
                  case ColorSpace::CIELab:
                  case ColorSpace::CIELch:
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::RGB:
                     case ColorSpace::HSV:
                     case ColorSpace::HSI:
                        switch ( m_image.ColorSpace() )
                        {
                        case ColorSpace::HSV:
                           targetRGBWS.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                           break;
                        case ColorSpace::HSI:
                           targetRGBWS.HSIToRGB( r0, r1, r2, r0, r1, r2 );
                           break;
                        default:
                           break;
                        }
                        targetRGBWS.RGBToCIEab( r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::CIEXYZ:
                        targetRGBWS.CIEXYZToCIELab( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::CIELab: // NOOP
                     case ColorSpace::CIELch: // NOOP
                        break;
                     default: // ?!
                        break;
                     }
 
                     switch ( m_luminance.ColorSpace() )
                     {
                     case ColorSpace::RGB:
                     case ColorSpace::HSV:
                     case ColorSpace::HSI:
                        switch ( m_luminance.ColorSpace() )
                        {
                        case ColorSpace::HSV:
                           sourceRGBWS.HSVToRGB( s0, s1, s2, s0, s1, s2 );
                           break;
                        case ColorSpace::HSI:
                           sourceRGBWS.HSIToRGB( s0, s1, s2, s0, s1, s2 );
                           break;
                        default:
                           break;
                        }
                        r0 = sourceRGBWS.CIEL( s0, s1, s2 );
                        break;
                     case ColorSpace::CIEXYZ:
                        sourceRGBWS.CIEXYZToCIELab( r0, s1, s2, s0, s1, s2 );
                        break;
                     case ColorSpace::CIELab:
                     case ColorSpace::CIELch:
                        r0 = s0;
                        break;
                     default: // ?!
                        break;
                     }
 
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::RGB:
                     case ColorSpace::HSV:
                     case ColorSpace::HSI:
                        targetRGBWS.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                        switch ( m_image.ColorSpace() )
                        {
                        case ColorSpace::HSV:
                           targetRGBWS.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                           break;
                        case ColorSpace::HSI:
                           targetRGBWS.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                           break;
                        default: // RGB
                           break;
                        }
                        break;
                     case ColorSpace::CIEXYZ:
                        targetRGBWS.CIELabToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::CIELab: // NOOP
                     case ColorSpace::CIELch: // NOOP
                        break;
                     default: // ?!
                        break;
                     }
                     break;
 
                  default: // ?!
                     break;
                  }
 
                  *f0 = P::ToSample( r0 );
                  *f1 = P::ToSample( r1 );
                  *f2 = P::ToSample( r2 );
 
                  UPDATE_THREAD_MONITOR( 65536 )
               }
            }
         }
      }
 
   private:
 
            GenericImage&     m_image;
      const GenericImage<P1>& m_luminance;
            ThreadData&       m_data;
      const Point&            m_target;
      const Rect&             m_rect;
            int               m_firstRow, m_endRow;
   };
 
   // -------------------------------------------------------------------------
 
   template <class P1>
   class SetLightnessThread : public Thread
   {
   public:
 
      SetLightnessThread( GenericImage& image, const GenericImage<P1>& lightness, ThreadData& data,
                          const Point& target, const Rect& rect, int firstRow, int endRow )
         : m_image( image )
         , m_lightness( lightness )
         , m_data( data )
         , m_target( target )
         , m_rect( rect )
         , m_firstRow( firstRow )
         , m_endRow( endRow )
      {
      }
 
      void Run() final
      {
         INIT_THREAD_MONITOR()
 
         const RGBColorSystem& sourceRGBWS = m_lightness.RGBWorkingSpace();
         const RGBColorSystem& targetRGBWS = m_image.RGBWorkingSpace();
 
         typename P::sample* f0 = m_image.PixelAddress( m_target.x, m_target.y + m_firstRow, 0 );
         typename P::sample* f1 = m_image.PixelAddress( m_target.x, m_target.y + m_firstRow, 1 );
         typename P::sample* f2 = m_image.PixelAddress( m_target.x, m_target.y + m_firstRow, 2 );
 
         if ( m_lightness.ColorSpace() == ColorSpace::Gray ||
              m_lightness.ColorSpace() == ColorSpace::CIELab || m_lightness.ColorSpace() == ColorSpace::CIELch )
         {
            const typename P1::sample* fL = m_lightness.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 0 );
 
            for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width(), dwL = m_lightness.Width()-m_rect.Width();
                  y < m_endRow;
                  ++y, f0 += dw, f1 += dw, f2 += dw, fL += dwL )
            {
               const typename P::sample* fN = f0 + m_rect.Width();
 
               for ( ; f0 < fN; ++f0, ++f1, ++f2, ++fL )
               {
                  RGBColorSystem::sample r0, r1, r2, rL;
                  P::FromSample(  r0, *f0 );
                  P::FromSample(  r1, *f1 );
                  P::FromSample(  r2, *f2 );
                  P1::FromSample( rL, *fL );
 
                  switch ( m_image.ColorSpace() )
                  {
                  case ColorSpace::RGB:
                  case ColorSpace::HSV:
                  case ColorSpace::HSI:
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::HSV:
                        targetRGBWS.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::HSI:
                        targetRGBWS.HSIToRGB( r0, r1, r2, r0, r1, r2 );
                        break;
                     default:
                        break;
                     }
                     targetRGBWS.RGBToCIEab( r1, r2, r0, r1, r2 );
                     targetRGBWS.CIELabToRGB( r0, r1, r2, rL, r1, r2 );
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::HSV:
                        targetRGBWS.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::HSI:
                        targetRGBWS.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                        break;
                     default:
                        break;
                     }
                     break;
 
                  case ColorSpace::CIEXYZ:
                     r1 = targetRGBWS.CIELToCIEY( rL );
                     break;
 
                  case ColorSpace::CIELab:
                  case ColorSpace::CIELch:
                     r0 = rL;
                     break;
 
                  default: // ???
                     break;
                  }
 
                  *f0 = P::ToSample( r0 );
                  *f1 = P::ToSample( r1 );
                  *f2 = P::ToSample( r2 );
 
                  UPDATE_THREAD_MONITOR( 65536 )
               }
            }
         }
         else
         {
            const typename P1::sample* g0 = m_lightness.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 0 );
            const typename P1::sample* g1 = m_lightness.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 1 );
            const typename P1::sample* g2 = m_lightness.PixelAddress( m_rect.x0, m_rect.y0 + m_firstRow, 2 );
 
            for ( int y = m_firstRow, dw = m_image.Width()-m_rect.Width(), dwL = m_lightness.Width()-m_rect.Width();
                  y < m_endRow;
                  ++y, f0 += dw, f1 += dw, f2 += dw, g0 += dwL, g1 += dwL, g2 += dwL )
            {
               const typename P::sample* fN = f0 + m_rect.Width();
 
               for ( ; f0 < fN; ++f0, ++f1, ++f2, ++g0, ++g1, ++g2 )
               {
                  typename RGBColorSystem::sample r0, r1, r2, s0, s1, s2;
                  P::FromSample(  r0, *f0 );
                  P::FromSample(  r1, *f1 );
                  P::FromSample(  r2, *f2 );
                  P1::FromSample( s0, *g0 );
                  P1::FromSample( s1, *g1 );
                  P1::FromSample( s2, *g2 );
 
                  switch ( m_image.ColorSpace() )
                  {
                  case ColorSpace::RGB:
                  case ColorSpace::HSV:
                  case ColorSpace::HSI:
                  case ColorSpace::CIEXYZ:
                  case ColorSpace::CIELab:
                  case ColorSpace::CIELch:
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::RGB:
                     case ColorSpace::HSV:
                     case ColorSpace::HSI:
                        switch ( m_image.ColorSpace() )
                        {
                        case ColorSpace::HSV:
                           targetRGBWS.HSVToRGB( r0, r1, r2, r0, r1, r2 );
                           break;
                        case ColorSpace::HSI:
                           targetRGBWS.HSIToRGB( r0, r1, r2, r0, r1, r2 );
                           break;
                        default:
                           break;
                        }
                        targetRGBWS.RGBToCIEab( r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::CIEXYZ:
                        targetRGBWS.CIEXYZToCIELab( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::CIELch:
                        targetRGBWS.CIELchToCIELab( r0, r1, r2, r0, r1, r2 );
                        break;
                     default:
                        break;
                     }
 
                     switch ( m_lightness.ColorSpace() )
                     {
                     case ColorSpace::RGB:
                     case ColorSpace::HSV:
                     case ColorSpace::HSI:
                        switch ( m_lightness.ColorSpace() )
                        {
                        case ColorSpace::HSV:
                           sourceRGBWS.HSVToRGB( s0, s1, s2, s0, s1, s2 );
                           break;
                        case ColorSpace::HSI:
                           sourceRGBWS.HSIToRGB( s0, s1, s2, s0, s1, s2 );
                           break;
                        default:
                           break;
                        }
                        r0 = sourceRGBWS.CIEL( s0, s1, s2 );
                        break;
                     case ColorSpace::CIEXYZ:
                        r0 = sourceRGBWS.CIEYToCIEL( s1 );
                        break;
                     default: // ???
                        break;
                     }
 
                     switch ( m_image.ColorSpace() )
                     {
                     case ColorSpace::RGB:
                     case ColorSpace::HSV:
                     case ColorSpace::HSI:
                        targetRGBWS.CIELabToRGB( r0, r1, r2, r0, r1, r2 );
                        switch ( m_image.ColorSpace() )
                        {
                        case ColorSpace::HSV:
                           targetRGBWS.RGBToHSV( r0, r1, r2, r0, r1, r2 );
                           break;
                        case ColorSpace::HSI:
                           targetRGBWS.RGBToHSI( r0, r1, r2, r0, r1, r2 );
                           break;
                        default:
                           break;
                        }
                        break;
                     case ColorSpace::CIEXYZ:
                        targetRGBWS.CIELabToCIEXYZ( r0, r1, r2, r0, r1, r2 );
                        break;
                     case ColorSpace::CIELch:
                        targetRGBWS.CIELabToCIELch( r0, r1, r2, r0, r1, r2 );
                        break;
                     default:
                        break;
                     }
 
                  default: // ???
                     break;
                  }
 
                  *f0 = P::ToSample( r0 );
                  *f1 = P::ToSample( r1 );
                  *f2 = P::ToSample( r2 );
 
                  UPDATE_THREAD_MONITOR( 65536 )
               }
            }
         }
      }
 
   private:
 
            GenericImage&     m_image;
      const GenericImage<P1>& m_lightness;
            ThreadData&       m_data;
      const Point&            m_target;
      const Rect&             m_rect;
            int               m_firstRow, m_endRow;
   };
 
   // -------------------------------------------------------------------------
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
   friend class pi::SharedImage;
#endif
};
 
#undef m_pixelData
#undef m_channelData
#undef m_allocator
#undef m_width
#undef m_height
#undef m_numberOfChannels
#undef m_colorSpace
#undef m_RGBWS
#undef m_channel
#undef m_lastChannel
#undef m_point
#undef m_rectangle
#undef m_clipLow
#undef m_clipHigh
#undef m_clippedLow
#undef m_clippedHigh
 
// ----------------------------------------------------------------------------
 
template <class P, typename T> inline
GenericImage<P> operator +( const GenericImage<P>& image, T scalar )
{
   GenericImage<P> result( image );
   (void)(result += scalar);
   return result;
}
 
template <class P, typename T> inline
GenericImage<P> operator +( T scalar, const GenericImage<P>& image )
{
   return image + scalar;
}
 
template <class P, typename T> inline
GenericImage<P> operator -( const GenericImage<P>& image, T scalar )
{
   GenericImage<P> result( image );
   (void)(result -= scalar);
   return result;
}
 
template <class P, typename T> inline
GenericImage<P> operator *( const GenericImage<P>& image, T scalar )
{
   GenericImage<P> result( image );
   (void)(result *= scalar);
   return result;
}
 
template <class P, typename T> inline
GenericImage<P> operator *( T scalar, const GenericImage<P>& image )
{
   return image * scalar;
}
 
template <class P, typename T> inline
GenericImage<P> operator /( const GenericImage<P>& image, T scalar )
{
   GenericImage<P> result( image );
   (void)(result /= scalar);
   return result;
}
 
template <class P, typename T> inline
GenericImage<P> operator ^( const GenericImage<P>& image, T scalar )
{
   GenericImage<P> result( image );
   (void)(result ^= scalar);
   return result;
}
 
// ----------------------------------------------------------------------------
 
template <class P1, class P2> inline
GenericImage<P1> operator +( const GenericImage<P1>& image1, const GenericImage<P2>& image2 )
{
   GenericImage<P1> result( image1 );
   (void)(result += image2);
   return result;
}
 
template <class P1, class P2> inline
GenericImage<P1> operator -( const GenericImage<P1>& image1, const GenericImage<P2>& image2 )
{
   GenericImage<P1> result( image1 );
   (void)(result -= image2);
   return result;
}
 
template <class P1, class P2> inline
GenericImage<P1> operator *( const GenericImage<P1>& image1, const GenericImage<P2>& image2 )
{
   GenericImage<P1> result( image1 );
   (void)(result *= image2);
   return result;
}
 
template <class P1, class P2> inline
GenericImage<P1> operator /( const GenericImage<P1>& image1, const GenericImage<P2>& image2 )
{
   GenericImage<P1> result( image1 );
   (void)(result /= image2);
   return result;
}
 
template <class P1, class P2> inline
GenericImage<P1> operator ^( const GenericImage<P1>& image1, const GenericImage<P2>& image2 )
{
   GenericImage<P1> result( image1 );
   (void)(result ^= image2);
   return result;
}
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_NO_IMAGE_INSTANTIATE
 
using FImage = GenericImage<FloatPixelTraits>;
 
using DImage = GenericImage<DoublePixelTraits>;
 
using FComplexImage = GenericImage<ComplexPixelTraits>;
 
using DComplexImage = GenericImage<DComplexPixelTraits>;
 
using UInt8Image = GenericImage<UInt8PixelTraits>;
 
using UInt16Image = GenericImage<UInt16PixelTraits>;
 
using UInt32Image = GenericImage<UInt32PixelTraits>;
 
using Image = FImage;
 
using ComplexImage = FComplexImage;
 
#endif   // __PCL_NO_IMAGE_INSTANTIATE
 
// ----------------------------------------------------------------------------
 
} // pcl
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_NO_IMAGE_VARIANT_AUTO
 
#ifndef __PCL_ImageVariant_h
#include <pcl/ImageVariant.h>
#endif
 
#endif   // __PCL_NO_IMAGE_VARIANT_AUTO
 
// ----------------------------------------------------------------------------
 
#endif   // __PCL_Image_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Image.h - Released 2025-02-21T12:13:32Z