ImageVariant.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/ImageVariant.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 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_ImageVariant_h
#define __PCL_ImageVariant_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/Image.h>
#include <pcl/ReferenceCounter.h>
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
namespace pi
{
   class SharedImage;
}
#endif
 
#define SOLVE_TEMPLATE( F )                  \
   if ( IsComplexSample() )                  \
      switch ( BitsPerSample() )             \
      {                                      \
      case 32: F( ComplexImage ); break;     \
      case 64: F( DComplexImage ); break;    \
      }                                      \
   else if ( IsFloatSample() )               \
      switch ( BitsPerSample() )             \
      {                                      \
      case 32: F( Image ); break;            \
      case 64: F( DImage ); break;           \
      }                                      \
   else                                      \
      switch ( BitsPerSample() )             \
      {                                      \
      case  8: F( UInt8Image ); break;       \
      case 16: F( UInt16Image ); break;      \
      case 32: F( UInt32Image ); break;      \
      }
 
#define SOLVE_TEMPLATE_2( I, F )             \
   if ( I.IsComplexSample() )                \
      switch ( I.BitsPerSample() )           \
      {                                      \
      case 32: F( ComplexImage ); break;     \
      case 64: F( DComplexImage ); break;    \
      }                                      \
   else if ( I.IsFloatSample() )             \
      switch ( I.BitsPerSample() )           \
      {                                      \
      case 32: F( Image ); break;            \
      case 64: F( DImage ); break;           \
      }                                      \
   else                                      \
      switch ( I.BitsPerSample() )           \
      {                                      \
      case  8: F( UInt8Image ); break;       \
      case 16: F( UInt16Image ); break;      \
      case 32: F( UInt32Image ); break;      \
      }
 
#define SOLVE_TEMPLATE_REAL( F )             \
   if ( IsFloatSample() )                    \
      switch ( BitsPerSample() )             \
      {                                      \
      case 32: F( Image ); break;            \
      case 64: F( DImage ); break;           \
      }                                      \
   else                                      \
      switch ( BitsPerSample() )             \
      {                                      \
      case  8: F( UInt8Image ); break;       \
      case 16: F( UInt16Image ); break;      \
      case 32: F( UInt32Image ); break;      \
      }
 
#define SOLVE_TEMPLATE_REAL_2( I, F )        \
   if ( I.IsFloatSample() )                  \
      switch ( I.BitsPerSample() )           \
      {                                      \
      case 32: F( Image ); break;            \
      case 64: F( DImage ); break;           \
      }                                      \
   else                                      \
      switch ( I.BitsPerSample() )           \
      {                                      \
      case  8: F( UInt8Image ); break;       \
      case 16: F( UInt16Image ); break;      \
      case 32: F( UInt32Image ); break;      \
      }
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
namespace SwapCompression
{
   enum value_type
   {
      None,     // Do not use compression.
      ZLib,     // ZLib (deflate) compression.
      ZLib_SH,  // ZLib (deflate) compression with byte shuffling.
      LZ4,      // LZ4 fast compression.
      LZ4_Sh,   // LZ4 fast compression with byte shuffling.
      LZ4HC,    // LZ4-HC compression.
      LZ4HC_Sh, // LZ4-HC compression with byte shuffling.
      Zstd,     // Zstandard compression.
      Zstd_Sh,  // Zstandard compression with byte shuffling.
 
      NumberOfAlgorithms
   };
}
 
class PCL_CLASS ImageVariant
{
public:
 
   using color_space = AbstractImage::color_space;
 
   using image_op = ImageOp::value_type;
 
   /*
    * An enumerated type that represents a compression algorithm for raw
    * storage file generation. Valid constants for this enumeration are defined
    * in the SwapCompression namespace.
    */
   using swap_compression = SwapCompression::value_type;
 
   ImageVariant()
   {
      m_data = new Data;
   }
 
   template <class P>
   ImageVariant( GenericImage<P>* image )
   {
      m_data = new Data;
      m_data->Update( image );
   }
 
   ImageVariant( const ImageVariant& image )
      : m_data( image.m_data )
   {
      m_data->Attach();
   }
 
   ImageVariant( ImageVariant&& image )
      : m_data( image.m_data )
   {
      image.m_data = nullptr;
   }
 
   virtual ~ImageVariant()
   {
      if ( m_data != nullptr )
      {
         DetachFromData();
         m_data = nullptr;
      }
   }
 
   const AbstractImage* ImagePtr() const noexcept
   {
      return m_data->image;
   }
 
   AbstractImage* ImagePtr() noexcept
   {
      return m_data->image;
   }
 
   bool IsSameImage( const ImageVariant& image ) const noexcept
   {
      return m_data->image == image.m_data->image;
   }
 
   bool IsFloatSample() const noexcept
   {
      return m_data->isFloatSample;
   }
 
   bool IsComplexSample() const noexcept
   {
      return m_data->isComplexSample;
   }
 
   int BitsPerSample() const noexcept
   {
      return m_data->bitsPerSample;
   }
 
   int BytesPerSample() const noexcept
   {
      return m_data->bitsPerSample >> 3;
   }
 
   int Width() const noexcept
   {
      return m_data->image ? m_data->image->Width() : 0;
   }
 
   int Height() const noexcept
   {
      return m_data->image ? m_data->image->Height() : 0;
   }
 
   size_type NumberOfPixels() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfPixels() : 0;
   }
 
   int NumberOfChannels() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfChannels() : 0;
   }
 
   int LastChannel() const noexcept
   {
      return m_data->image ? m_data->image->LastChannel() : -1;
   }
 
   bool IsValidChannelIndex( int c ) const noexcept
   {
      return m_data->image && m_data->image->IsValidChannelIndex( c );
   }
 
   int NumberOfNominalChannels() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfNominalChannels() : 0;
   }
 
   bool HasAlphaChannels() const noexcept
   {
      return m_data->image && m_data->image->HasAlphaChannels();
   }
 
   int NumberOfAlphaChannels() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfAlphaChannels() : 0;
   }
 
   size_type NumberOfSamples() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfSamples() : 0;
   }
 
   size_type NumberOfNominalSamples() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfNominalSamples() : 0;
   }
 
   size_type NumberOfAlphaSamples() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfAlphaSamples() : 0;
   }
 
   Rect Bounds() const noexcept
   {
      return m_data->image ? m_data->image->Bounds() : Rect( 0 );
   }
 
   template <typename T>
   bool Includes( const GenericPoint<T>& p ) const noexcept
   {
      return m_data->image && m_data->image->Includes( p );
   }
 
   template <typename T>
   bool Includes( const GenericRectangle<T>& r ) const noexcept
   {
      return m_data->image && m_data->image->Includes( r );
   }
 
   template <typename T>
   bool Includes( T x0, T y0, T x1, T y1 ) const noexcept
   {
      return m_data->image && m_data->image->Includes( x0, y0, x1, y1 );
   }
 
   template <typename T>
   bool Includes( T x, T y ) const noexcept
   {
      return m_data->image && m_data->image->Includes( x, y );
   }
 
   template <typename T>
   bool Intersects( const pcl::GenericRectangle<T>& r ) const noexcept
   {
      return m_data->image && m_data->image->Intersects( r );
   }
 
   template <typename T>
   bool Intersects( T x0, T y0, T x1, T y1 ) const noexcept
   {
      return m_data->image && m_data->image->Intersects( x0, y0, x1, y1 );
   }
 
   template <typename T>
   bool Clip( pcl::GenericPoint<T>& p ) const noexcept
   {
      return m_data->image && m_data->image->Clip( p );
   }
 
   template <typename T>
   bool Clip( T& x, T& y ) const noexcept
   {
      return m_data->image && m_data->image->Clip( x, y );
   }
 
   template <typename T>
   bool Clip( pcl::GenericRectangle<T>& r ) const noexcept
   {
      return m_data->image && m_data->image->Clip( r );
   }
 
   template <typename T>
   bool Clip( T& x0, T& y0, T& x1, T& y1 ) const noexcept
   {
      return m_data->image && m_data->image->Clip( x0, y0, x1, y1 );
   }
 
   void SelectChannel( int c ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectChannel( c );
   }
 
   int SelectedChannel() const noexcept
   {
      return m_data->image ? m_data->image->SelectedChannel() : -1;
   }
 
   void SelectChannelRange( int c0, int c1 ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectChannelRange( c0, c1 );
   }
 
   void SelectNominalChannels() const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectNominalChannels();
   }
 
   void SelectAlphaChannels() const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectAlphaChannels();
   }
 
   void ResetChannelRange() const noexcept
   {
      if ( m_data->image )
         m_data->image->ResetChannelRange();
   }
 
   int NumberOfSelectedChannels() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfSelectedChannels() : 0;
   }
 
   int FirstSelectedChannel() const noexcept
   {
      return m_data->image ? m_data->image->FirstSelectedChannel() : -1;
   }
 
   int LastSelectedChannel() const noexcept
   {
      return m_data->image ? m_data->image->LastSelectedChannel() : -1;
   }
 
   void GetSelectedChannelRange( int& c0, int& c1 ) const noexcept
   {
      if ( m_data->image )
         m_data->image->GetSelectedChannelRange( c0, c1 );
   }
 
   void SelectPoint( int x, int y ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectPoint( x, y );
   }
 
   void SelectPoint( const Point& p ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectPoint( p );
   }
 
   void ResetPoint() const noexcept
   {
      if ( m_data->image )
         m_data->image->ResetPoint();
   }
 
   Point SelectedPoint() const noexcept
   {
      return m_data->image ? m_data->image->SelectedPoint() : Point( 0 );
   }
 
   void SelectRectangle( int x0, int y0, int x1, int y1 ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectRectangle( x0, y0, x1, y1 );
   }
 
   void SelectRectangle( const Point& p0, const Point& p1 ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectRectangle( p0, p1 );
   }
 
   void SelectRectangle( const Rect& r ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SelectRectangle( r );
   }
 
   void ResetSelection() const noexcept
   {
      if ( m_data->image )
         m_data->image->ResetSelection();
   }
 
   bool IsEmptySelection() const noexcept
   {
      return m_data->image ? m_data->image->IsEmptySelection() : false;
   }
 
   bool IsFullSelection() const noexcept
   {
      return m_data->image ? m_data->image->IsFullSelection() : false;
   }
 
   Rect SelectedRectangle() const noexcept
   {
      return m_data->image ? m_data->image->SelectedRectangle() : Rect( 0 );
   }
 
   bool IsCompletelySelected() const noexcept
   {
      return m_data->image ? m_data->image->IsCompletelySelected() : false;
   }
 
   size_type NumberOfSelectedPixels() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfSelectedPixels() : 0;
   }
 
   size_type NumberOfSelectedSamples() const noexcept
   {
      return m_data->image ? m_data->image->NumberOfSelectedSamples() : 0;
   }
 
   bool IsRangeClippingEnabled() const noexcept
   {
      return m_data->image ? m_data->image->IsRangeClippingEnabled() : false;
   }
 
   bool IsLowRangeClippingEnabled() const noexcept
   {
      return m_data->image ? m_data->image->IsLowRangeClippingEnabled() : false;
   }
 
   bool IsHighRangeClippingEnabled() const noexcept
   {
      return m_data->image ? m_data->image->IsHighRangeClippingEnabled() : false;
   }
 
   void EnableRangeClipping( bool enableLow = true, bool enableHigh = true ) const noexcept
   {
      if ( m_data->image )
         m_data->image->EnableRangeClipping( enableLow, enableHigh );
   }
 
   void DisableRangeClipping( bool disableLow = true, bool disableHigh = true ) const noexcept
   {
      if ( m_data->image )
         m_data->image->DisableRangeClipping( disableLow, disableHigh );
   }
 
   double RangeClipLow() const noexcept
   {
      return m_data->image ? m_data->image->RangeClipLow() : 0.0;
   }
 
   double RangeClipHigh() const noexcept
   {
      return m_data->image ? m_data->image->RangeClipHigh() : 0.0;
   }
 
   void SetRangeClipLow( double clipLow ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SetRangeClipLow( clipLow );
   }
 
   void SetRangeClipHigh( double clipHigh ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SetRangeClipHigh( clipHigh );
   }
 
   void SetRangeClipping( double clipLow, double clipHigh ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SetRangeClipping( clipLow, clipHigh );
   }
 
   void ResetRangeClipping() const noexcept
   {
      if ( m_data->image )
         m_data->image->ResetRangeClipping();
   }
 
   void ResetSelections() const noexcept
   {
      if ( m_data->image )
         m_data->image->ResetSelections();
   }
 
   ImageSelections& Selections() const noexcept
   {
      return m_data->image->Selections();
   }
 
   void PushSelections() const
   {
      if ( m_data->image )
         m_data->image->PushSelections();
   }
 
   void PopSelections() const
   {
      if ( m_data->image )
         m_data->image->PopSelections();
   }
 
   bool CanPopSelections() const noexcept
   {
      return m_data->image ? m_data->image->CanPopSelections() : false;
   }
 
   StatusMonitor& Status() const noexcept
   {
      PCL_PRECONDITION( m_data->image != nullptr )
      return m_data->image->Status();
   }
 
   pcl::StatusCallback* StatusCallback() const noexcept
   {
      return m_data->image ? m_data->image->StatusCallback() : nullptr;
   }
 
   void SetStatusCallback( pcl::StatusCallback* callback ) const noexcept
   {
      if ( m_data->image )
         m_data->image->SetStatusCallback( callback );
   }
 
   bool IsParallelProcessingEnabled() const noexcept
   {
      return m_data->image != nullptr && m_data->image->IsParallelProcessingEnabled();
   }
 
   void EnableParallelProcessing( bool enable = true, int maxProcessors = 0 ) noexcept
   {
      if ( m_data->image )
         m_data->image->EnableParallelProcessing( enable, maxProcessors );
   }
 
   void DisableParallelProcessing( bool disable = true ) noexcept
   {
      if ( m_data->image )
         m_data->image->DisableParallelProcessing( disable );
   }
 
   int MaxProcessors() const noexcept
   {
      return m_data->image ? m_data->image->MaxProcessors() : 0;
   }
 
   void SetMaxProcessors( int maxProcessors ) noexcept
   {
      if ( m_data->image )
         m_data->image->SetMaxProcessors( maxProcessors );
   }
 
   size_type LineSize() const noexcept
   {
      return m_data->image ? BytesPerSample() * size_type( m_data->image->Width() ) : 0;
   }
 
   size_type ChannelSize() const noexcept
   {
      return BytesPerSample() * NumberOfPixels();
   }
 
   size_type ImageSize() const noexcept
   {
      return ChannelSize() * size_type( NumberOfChannels() );
   }
 
   size_type NominalSize() const noexcept
   {
      return ChannelSize() * size_type( NumberOfNominalChannels() );
   }
 
   size_type AlphaSize() const noexcept
   {
      return ChannelSize() * size_type( NumberOfAlphaChannels() );
   }
 
   bool IsColor() const noexcept
   {
      return m_data->image && m_data->image->IsColor();
   }
 
   color_space ColorSpace() const noexcept
   {
      return m_data->image ? m_data->image->ColorSpace() : ColorSpace::Unknown;
   }
 
   String ChannelId( int c ) const noexcept
   {
      return m_data->image ? m_data->image->ChannelId( c ) : String();
   }
 
   const RGBColorSystem& RGBWorkingSpace() const noexcept
   {
      PCL_PRECONDITION( m_data->image != nullptr )
      return m_data->image->RGBWorkingSpace();
   }
 
   void SetRGBWorkingSpace( const RGBColorSystem& rgbws )
   {
      if ( m_data->image )
         m_data->image->SetRGBWorkingSpace( rgbws );
   }
 
   // -------------------------------------------------------------------------
 
#define __ABSOLUTE_DIFFERENCE( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).AbsoluteDifference( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant AbsoluteDifference( T scalar,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __ABSOLUTE_DIFFERENCE )
      return result;
   }
 
#undef __ABSOLUTE_DIFFERENCE
 
   // -------------------------------------------------------------------------
 
#define __ABSOLUTE_VALUE( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).AbsoluteValue( rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant AbsoluteValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __ABSOLUTE_VALUE )
      return result;
   }
 
#undef __ABSOLUTE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __ADD( I ) \
   static_cast<pcl::I&>( **this ).Add( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Add( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __ADD )
      return *this;
   }
 
#undef __ADD
 
   // -------------------------------------------------------------------------
 
#define __ADD_1( I ) \
   ImageVariant::Add( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __ADD_2( I ) \
   image1.Add( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Add( GenericImage<P>& image1, const ImageVariant& image2,
             const Point& point, int channel,
             const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __ADD_2 )
   }
 
public:
 
   ImageVariant& Add( const ImageVariant& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __ADD_1 )
      return *this;
   }
 
#undef __ADD_1
#undef __ADD_2
 
   // -------------------------------------------------------------------------
 
#define __ADDED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Added( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Added( T scalar,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __ADDED )
      return result;
   }
 
#undef __ADDED
 
   // -------------------------------------------------------------------------
 
#define __ALLOCATE_DATA( I ) \
   static_cast<pcl::I&>( **this ).AllocateData( width, height, numberOfChannels, colorSpace )
 
   ImageVariant& AllocateData( int width, int height, int numberOfChannels = 1, color_space colorSpace = ColorSpace::Gray )
   {
      if ( !*this )
         CreateImage();
      SOLVE_TEMPLATE( __ALLOCATE_DATA )
      return *this;
   }
 
#undef __ALLOCATE_DATA
 
   // -------------------------------------------------------------------------
 
#define __ALLOCATE_DATA( I ) \
   static_cast<pcl::I&>( **this ).AllocateData( rect, numberOfChannels, colorSpace )
 
   ImageVariant& AllocateData( const Rect& rect, int numberOfChannels = 1, color_space colorSpace = ColorSpace::Gray )
   {
      if ( !*this )
         CreateImage();
      SOLVE_TEMPLATE( __ALLOCATE_DATA )
      return *this;
   }
 
#undef __ALLOCATE_DATA
 
   // -------------------------------------------------------------------------
 
#define __AND( I ) \
   static_cast<pcl::I&>( **this ).And( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& And( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __AND )
      return *this;
   }
 
#undef __AND
 
   // -------------------------------------------------------------------------
 
#define __AND_1( I ) \
   ImageVariant::And( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __AND_2( I ) \
   image1.And( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void And( GenericImage<P>& image1, const ImageVariant& image2,
             const Point& point, int channel,
             const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_REAL_2( image2, __AND_2 )
   }
 
public:
 
   ImageVariant& And( const ImageVariant& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE_REAL( __AND_1 )
      return *this;
   }
 
#undef __AND_1
#undef __AND_2
 
   // -------------------------------------------------------------------------
 
#define __APPLIED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Applied( scalar, op, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Applied( T scalar, image_op op = ImageOp::Mov,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __APPLIED )
      return result;
   }
 
#undef __APPLIED
 
   // -------------------------------------------------------------------------
 
#define __APPLIED_1( I ) \
   result = ImageVariant::Applied( static_cast<const pcl::I&>( **this ), image, op, point, channel, rect, firstChannel, lastChannel )
 
#define __APPLIED_2( I ) \
   result.SetImage( *new pcl::I( image1.Applied( static_cast<const pcl::I&>( *image2 ), op, point, channel, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
private:
 
   template <class P> static
   ImageVariant Applied( const GenericImage<P>& image1, const ImageVariant& image2,
                         image_op op, const Point& point, int channel,
                         const Rect& rect, int firstChannel, int lastChannel )
   {
      ImageVariant result;
      SOLVE_TEMPLATE_2( image2, __APPLIED_2 )
      return result;
   }
 
public:
 
   ImageVariant Applied( const ImageVariant& 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
   {
      ImageVariant result;
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __APPLIED_1 )
      return result;
   }
 
#undef __APPLIED_1
#undef __APPLIED_2
 
   // -------------------------------------------------------------------------
 
#define __APPLIED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Applied( transformation, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Applied( const ImageTransformation& transformation,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __APPLIED )
      return result;
   }
 
#undef __APPLIED
 
   // -------------------------------------------------------------------------
 
#define __APPLY( I ) \
   static_cast<pcl::I&>( **this ).Apply( scalar, op, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Apply( T scalar, image_op op = ImageOp::Mov,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __APPLY )
      return *this;
   }
 
#undef __APPLY
 
   // -------------------------------------------------------------------------
 
#define __APPLY_1( I ) \
   ImageVariant::Apply( static_cast<pcl::I&>( **this ), image, op, point, channel, rect, firstChannel, lastChannel )
 
#define __APPLY_2( I ) \
   image1.Apply( static_cast<const pcl::I&>( *image2 ), op, point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Apply( GenericImage<P>& image1, const ImageVariant& image2,
               image_op op, const Point& point, int channel,
               const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __APPLY_2 )
   }
 
public:
 
   ImageVariant& Apply( const ImageVariant& 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 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __APPLY_1 )
      return *this;
   }
 
#undef __APPLY_1
#undef __APPLY_2
 
   // -------------------------------------------------------------------------
 
#define __APPLY( I ) \
   static_cast<pcl::I&>( **this ).Apply( transformation, rect, firstChannel, lastChannel )
 
   ImageVariant& Apply( const ImageTransformation& transformation,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __APPLY )
      return *this;
   }
 
#undef __APPLY
 
   // -------------------------------------------------------------------------
 
#define __ASSIGN_IMAGE_1( I ) \
   ImageVariant::AssignImage( static_cast<pcl::I&>( **this ), image, rect, firstChannel, lastChannel )
 
#define __ASSIGN_IMAGE_2( I ) \
   image1.Assign( static_cast<const pcl::I&>( *image2 ), rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void AssignImage( GenericImage<P>& image1, const ImageVariant& image2,
                     const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __ASSIGN_IMAGE_2 )
   }
 
public:
 
   ImageVariant& AssignImage( const ImageVariant& image,
                              const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __ASSIGN_IMAGE_1 )
      return *this;
   }
 
#undef __ASSIGN_IMAGE_1
#undef __ASSIGN_IMAGE_2
 
   // -------------------------------------------------------------------------
 
#define __AVG_DEV( I ) \
   result = static_cast<const pcl::I&>( **this ).AvgDev( center, rect, firstChannel, lastChannel, maxProcessors )
 
   double AvgDev( double center,
                  const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                  int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __AVG_DEV )
      return result;
   }
 
#undef __AVG_DEV
 
   // -------------------------------------------------------------------------
 
#define __2SIDED_AVG_DEV( I ) \
   result = static_cast<const pcl::I&>( **this ).TwoSidedAvgDev( center, rect, firstChannel, lastChannel, maxProcessors )
 
   TwoSidedEstimate TwoSidedAvgDev( double center,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      TwoSidedEstimate result( 0 );
      if ( *this )
         SOLVE_TEMPLATE( __2SIDED_AVG_DEV )
      return result;
   }
 
#undef __2SIDED_AVG_DEV
 
   // -------------------------------------------------------------------------
 
#define __BINARIZE( I ) \
   static_cast<pcl::I&>( **this ).Binarize( threshold, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Binarize( T threshold, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __BINARIZE )
      return *this;
   }
 
#undef __BINARIZE
 
   // -------------------------------------------------------------------------
 
#define __BINARIZE( I ) \
   static_cast<pcl::I&>( **this ).Binarize( rect, firstChannel, lastChannel )
 
   ImageVariant& Binarize( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __BINARIZE )
      return *this;
   }
 
#undef __BINARIZE
 
   // -------------------------------------------------------------------------
 
#define __BINARIZED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Binarized( threshold, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Binarized( T threshold, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __BINARIZED )
      return result;
   }
 
#undef __BINARIZED
 
   // -------------------------------------------------------------------------
 
#define __BINARIZED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Binarized( rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Binarized( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __BINARIZED )
      return result;
   }
 
#undef __BINARIZED
 
   // -------------------------------------------------------------------------
 
#define __PBMV( I ) \
   result = static_cast<const pcl::I&>( **this ).BendMidvariance( center, beta, rect, firstChannel, lastChannel, maxProcessors )
 
   double BendMidvariance( double center, double beta = 0.2,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                           int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __PBMV )
      return result;
   }
 
#undef __PBMV
 
   // -------------------------------------------------------------------------
 
#define __BWMV( I ) \
   result = static_cast<const pcl::I&>( **this ).BiweightMidvariance( center, sigma, k, reducedLength, rect, firstChannel, lastChannel, maxProcessors )
 
   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 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __BWMV )
      return result;
   }
 
#undef __BWMV
 
   // -------------------------------------------------------------------------
 
#define __2SIDED_BWMV( I ) \
   result = static_cast<const pcl::I&>( **this ).TwoSidedBiweightMidvariance( center, sigma, k, reducedLength, rect, firstChannel, lastChannel, maxProcessors )
 
   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
   {
      TwoSidedEstimate result( 0 );
      if ( *this )
         SOLVE_TEMPLATE( __2SIDED_BWMV )
      return result;
   }
 
#undef __2SIDED_BWMV
 
   // -------------------------------------------------------------------------
 
#define __BLACK( I ) \
   static_cast<pcl::I&>( **this ).Black( rect, firstChannel, lastChannel )
 
   ImageVariant& Black( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __BLACK )
      return *this;
   }
 
#undef __BLACK
 
   // -------------------------------------------------------------------------
 
#define __BLEND( I ) \
   static_cast<pcl::I&>( **this ).Blend( bitmap, point, rect )
 
   ImageVariant& Blend( const Bitmap& bitmap,
                        const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ) )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __BLEND )
      return *this;
   }
 
#undef __BLEND
 
   // -------------------------------------------------------------------------
 
#define __BLENDED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Blended( bitmap, point, rect ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Blended( const Bitmap& bitmap, const Point& point = Point( int_max ), const Rect& rect = Rect( 0 ) ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __BLENDED )
      return result;
   }
 
#undef __BLENDED
 
   // -------------------------------------------------------------------------
 
#define __COUNT( I ) \
   result = static_cast<const pcl::I&>( **this ).Count( rect, firstChannel, lastChannel, maxProcessors )
 
   uint64 Count( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1, int maxProcessors = 0 ) const
   {
      uint64 result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __COUNT )
      return result;
   }
 
#undef __COUNT
 
   // -------------------------------------------------------------------------
 
#define __CREATE_ALPHA_CHANNELS( I ) \
   static_cast<pcl::I&>( **this ).CreateAlphaChannels( n )
 
   void CreateAlphaChannels( int n )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CREATE_ALPHA_CHANNELS )
   }
 
#undef __CREATE_ALPHA_CHANNELS
 
   // -------------------------------------------------------------------------
 
#define __CROP( I ) \
   static_cast<pcl::I&>( **this ).Crop( fillValues )
 
   template <typename T>
   ImageVariant& Crop( const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP )
      return *this;
   }
 
#undef __CROP
 
   // -------------------------------------------------------------------------
 
#define __CROP( I ) \
   static_cast<pcl::I&>( **this ).Crop()
 
   ImageVariant& Crop()
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP )
      return *this;
   }
 
#undef __CROP
 
   // -------------------------------------------------------------------------
 
#define __CROP_BY( I ) \
   static_cast<pcl::I&>( **this ).CropBy( left, top, right, bottom, fillValues )
 
   template <typename T>
   ImageVariant& CropBy( int left, int top, int right, int bottom, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP_BY )
      return *this;
   }
 
#undef __CROP_BY
 
   // -------------------------------------------------------------------------
 
#define __CROP_BY( I ) \
   static_cast<pcl::I&>( **this ).CropBy( left, top, right, bottom )
 
   ImageVariant& CropBy( int left, int top, int right, int bottom )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP_BY )
      return *this;
   }
 
#undef __CROP_BY
 
   // -------------------------------------------------------------------------
 
#define __CROP_TO( I ) \
   static_cast<pcl::I&>( **this ).CropTo( rect, fillValues )
 
   template <typename T>
   ImageVariant& CropTo( const Rect& rect, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP_TO )
      return *this;
   }
 
#undef __CROP_TO
 
   // -------------------------------------------------------------------------
 
#define __CROP_TO( I ) \
   static_cast<pcl::I&>( **this ).CropTo( rect )
 
   ImageVariant& CropTo( const Rect& rect )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP_TO )
      return *this;
   }
 
#undef __CROP_TO
 
   // -------------------------------------------------------------------------
 
#define __CROP_TO( I ) \
   static_cast<pcl::I&>( **this ).CropTo( x0, y0, x1, y1, fillValues )
 
   template <typename T>
   ImageVariant& CropTo( int x0, int y0, int x1, int y1, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP_TO )
      return *this;
   }
 
#undef __CROP_TO
 
   // -------------------------------------------------------------------------
 
#define __CROP_TO( I ) \
   static_cast<pcl::I&>( **this ).CropTo( x0, y0, x1, y1 )
 
   ImageVariant& CropTo( int x0, int y0, int x1, int y1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __CROP_TO )
      return *this;
   }
 
#undef __CROP_TO
 
   // -------------------------------------------------------------------------
 
#define __DELETE_ALPHA_CHANNEL( I ) \
   static_cast<pcl::I&>( **this ).DeleteAlphaChannel( channel )
 
   void DeleteAlphaChannel( int channel )
   {
      if ( *this )
         SOLVE_TEMPLATE( __DELETE_ALPHA_CHANNEL )
   }
 
#undef __DELETE_ALPHA_CHANNEL
 
   // -------------------------------------------------------------------------
 
#define __DELETE_ALPHA_CHANNELS( I ) \
   static_cast<pcl::I&>( **this ).DeleteAlphaChannels()
 
   void DeleteAlphaChannels()
   {
      if ( *this )
         SOLVE_TEMPLATE( __DELETE_ALPHA_CHANNELS )
   }
 
#undef __DELETE_ALPHA_CHANNELS
 
   // -------------------------------------------------------------------------
 
#define __DIVIDE( I ) \
   static_cast<pcl::I&>( **this ).Divide( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Divide( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __DIVIDE )
      return *this;
   }
 
#undef __DIVIDE
 
   template <typename T>
   ImageVariant& Div( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Divide( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __DIVIDE_1( I ) \
   ImageVariant::Divide( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __DIVIDE_2( I ) \
   image1.Divide( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Divide( GenericImage<P>& image1, const ImageVariant& image2,
                const Point& point, int channel,
                const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __DIVIDE_2 )
   }
 
public:
 
   ImageVariant& Divide( const ImageVariant& image,
                         const Point& point = Point( int_max ), int channel = -1,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __DIVIDE_1 )
      return *this;
   }
 
#undef __DIVIDE_1
#undef __DIVIDE_2
 
   ImageVariant& Div( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __DIVIDED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Divided( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Divided( T scalar,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __DIVIDED )
      return result;
   }
 
#undef __DIVIDED
 
   // -------------------------------------------------------------------------
 
#define __EXCHANGE_1( I ) \
   ImageVariant::Exchange( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __EXCHANGE_2( I ) \
   image1.Exchange( static_cast<pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Exchange( GenericImage<P>& image1, ImageVariant& image2,
                  const Point& point, int channel,
                  const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __EXCHANGE_2 )
   }
 
public:
 
   ImageVariant& Exchange( ImageVariant& image,
                           const Point& point = Point( int_max ), int channel = -1,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __EXCHANGE_1 )
      return *this;
   }
 
#undef __EXCHANGE_1
#undef __EXCHANGE_2
 
   ImageVariant& Xchg( ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __FILL( I ) \
   static_cast<pcl::I&>( **this ).Fill( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Fill( T scalar,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __FILL )
      return *this;
   }
 
#undef __FILL
 
   // -------------------------------------------------------------------------
 
#define __FILL( I ) \
   static_cast<pcl::I&>( **this ).Fill( values, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Fill( const GenericVector<T>& values,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __FILL )
      return *this;
   }
 
#undef __FILL
 
   // -------------------------------------------------------------------------
 
#define __FILLED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Filled( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Filled( T scalar,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __FILLED )
      return result;
   }
 
#undef __FILLED
 
   // -------------------------------------------------------------------------
 
#define __FILLED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Filled( values, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Filled( const GenericVector<T>& values,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __FILLED )
      return result;
   }
 
#undef __FILLED
 
   // -------------------------------------------------------------------------
 
#define __FORGET_ALPHA_CHANNEL( I ) \
   static_cast<pcl::I&>( **this ).ForgetAlphaChannel( channel )
 
   void ForgetAlphaChannel( int channel )
   {
      if ( *this )
         SOLVE_TEMPLATE( __FORGET_ALPHA_CHANNEL )
   }
 
#undef __FORGET_ALPHA_CHANNEL
 
   // -------------------------------------------------------------------------
 
#define __FORGET_ALPHA_CHANNELS( I ) \
   static_cast<pcl::I&>( **this ).ForgetAlphaChannels()
 
   void ForgetAlphaChannels()
   {
      if ( *this )
         SOLVE_TEMPLATE( __FORGET_ALPHA_CHANNELS )
   }
 
#undef __FORGET_ALPHA_CHANNELS
 
   // -------------------------------------------------------------------------
 
#define __GET_COLUMN( I ) \
   static_cast<const pcl::I&>( **this ).GetColumn( buffer, x, channel )
 
   template <typename T>
   void GetColumn( T* buffer, int x, int channel = -1 ) const
   {
      PCL_PRECONDITION( buffer != 0 )
      if ( *this )
         SOLVE_TEMPLATE( __GET_COLUMN )
   }
 
#undef __GET_COLUMN
 
   // -------------------------------------------------------------------------
 
#define __GET_EXTREME_SAMPLE_VALUES( I ) \
   static_cast<const pcl::I&>( **this ).GetExtremeSampleValues( min, max, 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 ) const
   {
      PCL_PRECONDITION( buffer != 0 )
      if ( *this )
         SOLVE_TEMPLATE( __GET_EXTREME_SAMPLE_VALUES )
   }
 
#undef __GET_EXTREME_SAMPLE_VALUES
 
   // -------------------------------------------------------------------------
 
#define __GET_INTENSITY_1( I ) \
   ImageVariant::GetIntensity( Y, static_cast<const pcl::I&>( **this ), rect, maxProcessors )
 
#define __GET_INTENSITY_2( I ) \
   image.GetIntensity( static_cast<pcl::I&>( *Y ), rect, maxProcessors )
 
private:
 
   template <class P> static
   void GetIntensity( ImageVariant& Y, const GenericImage<P>& image, const Rect& rect, int maxProcessors )
   {
      if ( !Y.IsComplexSample() )
         SOLVE_TEMPLATE_REAL_2( Y, __GET_INTENSITY_2 )
   }
 
public:
 
   void GetIntensity( ImageVariant& Y, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const
   {
      if ( *this )
         if ( !IsComplexSample() )
         {
            if ( !Y )
               Y.CreateFloatImage( 32 );
 
            SOLVE_TEMPLATE_REAL( __GET_INTENSITY_1 )
         }
   }
 
#undef __GET_INTENSITY_1
#undef __GET_INTENSITY_2
 
   // -------------------------------------------------------------------------
 
#define __GET_LIGHTNESS_1( I ) \
   ImageVariant::GetLightness( L, static_cast<const pcl::I&>( **this ), rect, maxProcessors )
 
#define __GET_LIGHTNESS_2( I ) \
   image.GetLightness( static_cast<pcl::I&>( *L ), rect, maxProcessors )
 
private:
 
   template <class P> static
   void GetLightness( ImageVariant& L, const GenericImage<P>& image, const Rect& rect, int maxProcessors )
   {
      if ( !L.IsComplexSample() )
         SOLVE_TEMPLATE_REAL_2( L, __GET_LIGHTNESS_2 )
   }
 
public:
 
   void GetLightness( ImageVariant& L, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const
   {
      if ( *this )
         if ( !IsComplexSample() )
         {
            if ( !L )
               L.CreateFloatImage( ( BitsPerSample() < 32 ) ? 32 : ( IsFloatSample() ? BitsPerSample() : 64 ) );
 
            SOLVE_TEMPLATE_REAL( __GET_LIGHTNESS_1 )
         }
   }
 
#undef __GET_LIGHTNESS_1
#undef __GET_LIGHTNESS_2
 
   // -------------------------------------------------------------------------
 
#define __GET_LUMINANCE_1( I ) \
   ImageVariant::GetLuminance( Y, static_cast<const pcl::I&>( **this ), rect, maxProcessors )
 
#define __GET_LUMINANCE_2( I ) \
   image.GetLuminance( static_cast<pcl::I&>( *Y ), rect, maxProcessors )
 
private:
 
   template <class P> static
   void GetLuminance( ImageVariant& Y, const GenericImage<P>& image, const Rect& rect, int maxProcessors )
   {
      if ( !Y.IsComplexSample() )
         SOLVE_TEMPLATE_REAL_2( Y, __GET_LUMINANCE_2 )
   }
 
public:
 
   void GetLuminance( ImageVariant& Y, const Rect& rect = Rect( 0 ), int maxProcessors = 0 ) const
   {
      if ( *this )
         if ( !IsComplexSample() )
         {
            if ( !Y )
               Y.CreateFloatImage( ( BitsPerSample() < 32 ) ? 32 : ( IsFloatSample() ? BitsPerSample() : 64 ) );
 
            SOLVE_TEMPLATE_REAL( __GET_LUMINANCE_1 )
         }
   }
 
#undef __GET_LUMINANCE_1
#undef __GET_LUMINANCE_2
 
   // -------------------------------------------------------------------------
 
#define __GET_ROW( I ) \
   static_cast<const pcl::I&>( **this ).GetRow( buffer, y, channel )
 
   template <typename T>
   void GetRow( T* buffer, int y, int channel = -1 ) const
   {
      PCL_PRECONDITION( buffer != 0 )
      if ( *this )
         SOLVE_TEMPLATE( __GET_ROW )
   }
 
#undef __GET_ROW
 
   // -------------------------------------------------------------------------
 
#define __INVERT( I ) \
   static_cast<pcl::I&>( **this ).Invert( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Invert( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __INVERT )
      return *this;
   }
 
#undef __INVERT
 
   // -------------------------------------------------------------------------
 
#define __INVERT( I ) \
   static_cast<pcl::I&>( **this ).Invert( rect, firstChannel, lastChannel )
 
   ImageVariant& Invert( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __INVERT )
      return *this;
   }
 
#undef __INVERT
 
   // -------------------------------------------------------------------------
 
#define __INVERTED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Inverted( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Inverted( T scalar,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __INVERTED )
      return result;
   }
 
#undef __INVERTED
 
   // -------------------------------------------------------------------------
 
#define __INVERTED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Inverted( rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Inverted( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __INVERTED )
      return result;
   }
 
#undef __INVERTED
 
   // -------------------------------------------------------------------------
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
#define __IS_SHARED_IMAGE( I ) \
   result = static_cast<const pcl::I&>( **this ).IsShared()
 
   bool IsSharedImage() const noexcept
   {
      bool result = false;
      if ( *this )
         SOLVE_TEMPLATE( __IS_SHARED_IMAGE )
      return result;
   }
 
#undef __IS_SHARED_IMAGE
 
#endif   // !__PCL_BUILDING_PIXINSIGHT_APPLICATION
 
   // -------------------------------------------------------------------------
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
#define __SHARED_IMAGE_HANDLE( I ) \
   handle = static_cast<const pcl::I&>( **this ).Allocator().Handle()
 
   void* SharedImageHandle() const noexcept
   {
      void* handle = nullptr;
      if ( *this )
         SOLVE_TEMPLATE( __SHARED_IMAGE_HANDLE )
      return handle;
   }
 
#undef __SHARED_IMAGE_HANDLE
 
#endif   // !__PCL_BUILDING_PIXINSIGHT_APPLICATION
 
   // -------------------------------------------------------------------------
 
#define __IS_UNIQUE_IMAGE( I ) \
   result = static_cast<const pcl::I&>( **this ).IsUnique()
 
   bool IsUniqueImage() const noexcept
   {
      bool result = false;
      if ( *this )
         SOLVE_TEMPLATE( __IS_UNIQUE_IMAGE )
      return result;
   }
 
#undef __IS_UNIQUE_IMAGE
 
   // -------------------------------------------------------------------------
 
#define __LOCATE_EXTREME_SAMPLE_VALUES( I ) \
   static_cast<const pcl::I&>( **this ).LocateExtremeSampleValues( xmin, ymin, min, xmax, ymax, max, 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
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __LOCATE_EXTREME_SAMPLE_VALUES )
   }
 
#undef __LOCATE_EXTREME_SAMPLE_VALUES
 
   // -------------------------------------------------------------------------
 
#define __LOCATE_EXTREME_SAMPLE_VALUES( I ) \
   static_cast<const pcl::I&>( **this ).LocateExtremeSampleValues( pmin, min, pmax, max, rect, firstChannel, lastChannel, maxProcessors )
 
   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
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __LOCATE_EXTREME_SAMPLE_VALUES )
   }
 
#undef __LOCATE_EXTREME_SAMPLE_VALUES
 
   // -------------------------------------------------------------------------
 
#define __LOCATE_MAXIMUM_SAMPLE_VALUE( I ) \
   pcl::I::pixel_traits::FromSample( result, static_cast<const pcl::I&>( **this ).LocateMaximumSampleValue( xmax, ymax, rect, firstChannel, lastChannel, maxProcessors ) )
 
   double LocateMaximumSampleValue( int& xmax, int& ymax,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __LOCATE_MAXIMUM_SAMPLE_VALUE )
      return result;
   }
 
#undef __LOCATE_MAXIMUM_SAMPLE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __LOCATE_MAXIMUM_SAMPLE_VALUE( I ) \
   pcl::I::pixel_traits::FromSample( result, static_cast<const pcl::I&>( **this ).LocateMaximumSampleValue( pmax, rect, firstChannel, lastChannel, maxProcessors ) )
 
   double LocateMaximumSampleValue( Point& pmax,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __LOCATE_MAXIMUM_SAMPLE_VALUE )
      return result;
   }
 
#undef __LOCATE_MAXIMUM_SAMPLE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __LOCATE_MINIMUM_SAMPLE_VALUE( I ) \
   pcl::I::pixel_traits::FromSample( result, static_cast<const pcl::I&>( **this ).LocateMinimumSampleValue( xmin, ymin, rect, firstChannel, lastChannel, maxProcessors ) )
 
   double LocateMinimumSampleValue( int& xmin, int& ymin,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __LOCATE_MINIMUM_SAMPLE_VALUE )
      return result;
   }
 
#undef __LOCATE_MINIMUM_SAMPLE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __LOCATE_MINIMUM_SAMPLE_VALUE( I ) \
   pcl::I::pixel_traits::FromSample( result, static_cast<const pcl::I&>( **this ).LocateMinimumSampleValue( pmin, rect, firstChannel, lastChannel, maxProcessors ) )
 
   double LocateMinimumSampleValue( Point& pmin,
                                    const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                    int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __LOCATE_MINIMUM_SAMPLE_VALUE )
      return result;
   }
 
#undef __LOCATE_MINIMUM_SAMPLE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __MAD( I ) \
   result = static_cast<const pcl::I&>( **this ).MAD( center, rect, firstChannel, lastChannel, maxProcessors )
 
   double MAD( double center,
               const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
               int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MAD )
      return result;
   }
 
#undef __MAD
 
// -------------------------------------------------------------------------
 
#define __2SIDED_MAD( I ) \
   result = static_cast<const pcl::I&>( **this ).TwoSidedMAD( center, rect, firstChannel, lastChannel, maxProcessors )
 
   TwoSidedEstimate TwoSidedMAD( double center,
                                 const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                                 int maxProcessors = 0 ) const
   {
      TwoSidedEstimate result( 0 );
      if ( *this )
         SOLVE_TEMPLATE( __2SIDED_MAD )
      return result;
   }
 
#undef __2SIDED_MAD
 
// -------------------------------------------------------------------------
 
#define __MAXIMUM( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Maximum( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Maximum( T scalar,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __MAXIMUM )
      return result;
   }
 
#undef __MAXIMUM
 
   // -------------------------------------------------------------------------
 
#define __MAXIMUM_SAMPLE_VALUE( I ) \
   pcl::I::pixel_traits::FromSample( result, static_cast<const pcl::I&>( **this ).MaximumSampleValue( rect, firstChannel, lastChannel, maxProcessors ) )
 
   double MaximumSampleValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                              int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MAXIMUM_SAMPLE_VALUE )
      return result;
   }
 
#undef __MAXIMUM_SAMPLE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __MEAN( I ) \
   result = static_cast<const pcl::I&>( **this ).Mean( rect, firstChannel, lastChannel, maxProcessors )
 
   double Mean( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MEAN )
      return result;
   }
 
#undef __MEAN
 
   // -------------------------------------------------------------------------
 
#define __MEAN_OF_SQUARES( I ) \
   result = static_cast<const pcl::I&>( **this ).MeanOfSquares( rect, firstChannel, lastChannel, maxProcessors )
 
   double MeanOfSquares( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                         int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MEAN_OF_SQUARES )
      return result;
   }
 
#undef __MEAN_OF_SQUARES
 
   // -------------------------------------------------------------------------
 
#define __MEDIAN( I ) \
   result = static_cast<const pcl::I&>( **this ).Median( rect, firstChannel, lastChannel, maxProcessors )
 
   double Median( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                  int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MEDIAN )
      return result;
   }
 
#undef __MEDIAN
 
   // -------------------------------------------------------------------------
 
#define __ORDER_STATISTIC( I ) \
   result = static_cast<const pcl::I&>( **this ).OrderStatistic( k, rect, firstChannel, lastChannel, maxProcessors )
 
   double OrderStatistic( double k,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                          int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __ORDER_STATISTIC )
      return result;
   }
 
#undef __ORDER_STATISTIC
 
   // -------------------------------------------------------------------------
 
#define __MINIMUM( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Minimum( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Minimum( T scalar,
                         const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __MINIMUM )
      return result;
   }
 
#undef __MINIMUM
 
   // -------------------------------------------------------------------------
 
#define __MINIMUM_SAMPLE_VALUE( I ) \
   pcl::I::pixel_traits::FromSample( result, static_cast<const pcl::I&>( **this ).MinimumSampleValue( rect, firstChannel, lastChannel, maxProcessors ) )
 
   double MinimumSampleValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                              int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MINIMUM_SAMPLE_VALUE )
      return result;
   }
 
#undef __MINIMUM_SAMPLE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __MODULUS( I ) \
   result = static_cast<const pcl::I&>( **this ).Modulus( rect, firstChannel, lastChannel, maxProcessors )
 
   double Modulus( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                   int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __MODULUS )
      return result;
   }
 
#undef __MODULUS
 
   // -------------------------------------------------------------------------
 
#define __MOVE( I ) \
   static_cast<pcl::I&>( **this ).Move( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Move( T scalar,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __MOVE )
      return *this;
   }
 
#undef __MOVE
 
   template <typename T>
   ImageVariant& Mov( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Move( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __MOVE_1( I ) \
   ImageVariant::Move( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __MOVE_2( I ) \
   image1.Move( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Move( GenericImage<P>& image1, const ImageVariant& image2,
             const Point& point, int channel,
              const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __MOVE_2 )
   }
 
public:
 
   ImageVariant& Move( const ImageVariant& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __MOVE_1 )
      return *this;
   }
 
#undef __MOVE_1
#undef __MOVE_2
 
   ImageVariant& Mov( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __MULTIPLY( I ) \
   static_cast<pcl::I&>( **this ).Multiply( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Multiply( T scalar,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __MULTIPLY )
      return *this;
   }
 
#undef __MULTIPLY
 
   template <typename T>
   ImageVariant& Mul( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Multiply( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __MULTIPLY_1( I ) \
   ImageVariant::Multiply( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __MULTIPLY_2( I ) \
   image1.Multiply( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Multiply( GenericImage<P>& image1, const ImageVariant& image2,
                  const Point& point, int channel,
                  const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __MULTIPLY_2 )
   }
 
public:
 
   ImageVariant& Multiply( const ImageVariant& image,
                           const Point& point = Point( int_max ), int channel = -1,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __MULTIPLY_1 )
      return *this;
   }
 
#undef __MULTIPLY_1
#undef __MULTIPLY_2
 
   ImageVariant& Mul( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __MULTIPLIED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Multiplied( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Multiplied( T scalar,
                            const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __MULTIPLIED )
      return result;
   }
 
#undef __MULTIPLIED
 
   // -------------------------------------------------------------------------
 
#define __NAND( I ) \
   static_cast<pcl::I&>( **this ).Nand( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Nand( T scalar,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NAND )
      return *this;
   }
 
#undef __NAND
 
   // -------------------------------------------------------------------------
 
#define __NAND_1( I ) \
   ImageVariant::Nand( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __NAND_2( I ) \
   image1.Nand( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Nand( GenericImage<P>& image1, const ImageVariant& image2,
              const Point& point, int channel,
              const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_REAL_2( image2, __NAND_2 )
   }
 
public:
 
   ImageVariant& Nand( const ImageVariant& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE_REAL( __NAND_1 )
      return *this;
   }
 
#undef __NAND_1
#undef __NAND_2
 
   // -------------------------------------------------------------------------
 
#define __NOR( I ) \
   static_cast<pcl::I&>( **this ).Nor( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Nor( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NOR )
      return *this;
   }
 
#undef __NOR
 
   // -------------------------------------------------------------------------
 
#define __NOR_1( I ) \
   ImageVariant::Nor( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __NOR_2( I ) \
   image1.Nor( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Nor( GenericImage<P>& image1, const ImageVariant& image2,
             const Point& point, int channel,
             const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_REAL_2( image2, __NOR_2 )
   }
 
public:
 
   ImageVariant& Nor( const ImageVariant& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE_REAL( __NOR_1 )
      return *this;
   }
 
#undef __NOR_1
#undef __NOR_2
 
   // -------------------------------------------------------------------------
 
#define __NORM( I ) \
   result = static_cast<const pcl::I&>( **this ).Norm( rect, firstChannel, lastChannel, maxProcessors )
 
   double Norm( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __NORM )
      return result;
   }
 
#undef __NORM
 
   // -------------------------------------------------------------------------
 
#define __NORMS( I ) \
   result = static_cast<const pcl::I&>( **this ).Norms( maxDegree, rect, firstChannel, lastChannel, maxProcessors )
 
   Vector Norms( int maxDegree, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                 int maxProcessors = 0 ) const
   {
      Vector result;
      if ( *this )
         SOLVE_TEMPLATE( __NORMS )
      return result;
   }
 
#undef __NORM
 
   // -------------------------------------------------------------------------
 
#define __NORMALIZE( I ) \
   static_cast<pcl::I&>( **this ).Normalize( lowerBound, upperBound, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Normalize( T lowerBound, T upperBound,
                            const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NORMALIZE )
      return *this;
   }
 
#undef __NORMALIZE
 
   // -------------------------------------------------------------------------
 
#define __NORMALIZE( I ) \
   static_cast<pcl::I&>( **this ).Normalize( rect, firstChannel, lastChannel )
 
   ImageVariant& Normalize( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NORMALIZE )
      return *this;
   }
 
#undef __NORMALIZE
 
   // -------------------------------------------------------------------------
 
#define __NORMALIZED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Normalized( lowerBound, upperBound, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Normalized( T lowerBound, T upperBound,
                            const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NORMALIZED )
      return result;
   }
 
#undef __NORMALIZED
 
   // -------------------------------------------------------------------------
 
#define __NORMALIZED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Normalized( rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Normalized( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NORMALIZED )
      return result;
   }
 
#undef __NORMALIZED
 
   // -------------------------------------------------------------------------
 
#define __NOT( I ) \
   static_cast<pcl::I&>( **this ).Not( rect, firstChannel, lastChannel )
 
   ImageVariant& Not( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __NOT )
      return *this;
   }
 
#undef __NOT
 
   // -------------------------------------------------------------------------
 
#define __ONE( I ) \
   static_cast<pcl::I&>( **this ).One( rect, firstChannel, lastChannel )
 
   ImageVariant& One( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __ONE )
      return *this;
   }
 
#undef __ONE
 
   // -------------------------------------------------------------------------
 
#define __MULTIPLY( I ) \
   static_cast<pcl::I&>( **this ) *= scalar
 
   template <typename T>
   ImageVariant& operator *=( T scalar )
   {
      if ( *this )
         SOLVE_TEMPLATE( __MULTIPLY )
      return *this;
   }
 
#undef __MULTIPLY
 
   // -------------------------------------------------------------------------
 
#define __MULTIPLY_1( I ) \
   ImageVariant::Multiply( static_cast<pcl::I&>( **this ), image )
 
#define __MULTIPLY_2( I ) \
   image1 *= static_cast<const pcl::I&>( *image2 )
 
private:
 
   template <class P> static
   void Multiply( GenericImage<P>& image1, const ImageVariant& image2 )
   {
      SOLVE_TEMPLATE_2( image2, __MULTIPLY_2 )
   }
 
public:
 
   ImageVariant& operator *=( const ImageVariant& image )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __MULTIPLY_1 )
      return *this;
   }
 
#undef __MULTIPLY_1
#undef __MULTIPLY_2
 
   // -------------------------------------------------------------------------
 
#define __ADD( I ) \
   static_cast<pcl::I&>( **this ) += scalar
 
   template <typename T>
   ImageVariant& operator +=( T scalar )
   {
      if ( *this )
         SOLVE_TEMPLATE( __ADD )
      return *this;
   }
 
#undef __ADD
 
   // -------------------------------------------------------------------------
 
#define __ADD_1( I ) \
   ImageVariant::Add( static_cast<pcl::I&>( **this ), image )
 
#define __ADD_2( I ) \
   image1 += static_cast<const pcl::I&>( *image2 )
 
private:
 
   template <class P> static
   void Add( GenericImage<P>& image1, const ImageVariant& image2 )
   {
      SOLVE_TEMPLATE_2( image2, __ADD_2 )
   }
 
public:
 
   ImageVariant& operator +=( const ImageVariant& image )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __ADD_1 )
      return *this;
   }
 
#undef __ADD_1
#undef __ADD_2
 
   // -------------------------------------------------------------------------
 
#define __SUBTRACT( I ) \
   static_cast<pcl::I&>( **this ) -= scalar
 
   template <typename T>
   ImageVariant& operator -=( T scalar )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SUBTRACT )
      return *this;
   }
 
#undef __SUBTRACT
 
   // -------------------------------------------------------------------------
 
#define __SUBTRACT_1( I ) \
   ImageVariant::Subtract( static_cast<pcl::I&>( **this ), image )
 
#define __SUBTRACT_2( I ) \
   image1 -= static_cast<const pcl::I&>( *image2 )
 
private:
 
   template <class P> static
   void Subtract( GenericImage<P>& image1, const ImageVariant& image2 )
   {
      SOLVE_TEMPLATE_2( image2, __SUBTRACT_2 )
   }
 
public:
 
   ImageVariant& operator -=( const ImageVariant& image )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __SUBTRACT_1 )
      return *this;
   }
 
#undef __SUBTRACT_1
#undef __SUBTRACT_2
 
   // -------------------------------------------------------------------------
 
#define __DIVIDE( I ) \
   static_cast<pcl::I&>( **this ) /= scalar
 
   template <typename T>
   ImageVariant& operator /=( T scalar )
   {
      if ( *this )
         SOLVE_TEMPLATE( __DIVIDE )
      return *this;
   }
 
#undef __DIVIDE
 
   // -------------------------------------------------------------------------
 
#define __DIVIDE_1( I ) \
   ImageVariant::Divide( static_cast<pcl::I&>( **this ), image )
 
#define __DIVIDE_2( I ) \
   image1 /= static_cast<const pcl::I&>( *image2 )
 
private:
 
   template <class P> static
   void Divide( GenericImage<P>& image1, const ImageVariant& image2 )
   {
      SOLVE_TEMPLATE_2( image2, __DIVIDE_2 )
   }
 
public:
 
   ImageVariant& operator /=( const ImageVariant& image )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __DIVIDE_1 )
      return *this;
   }
 
#undef __DIVIDE_1
#undef __DIVIDE_2
 
   // -------------------------------------------------------------------------
 
#define __RAISE( I ) \
   static_cast<pcl::I&>( **this ) ^= scalar
 
   template <typename T>
   ImageVariant& operator ^=( T scalar )
   {
      if ( *this )
         SOLVE_TEMPLATE( __RAISE )
      return *this;
   }
 
#undef __RAISE
 
   // -------------------------------------------------------------------------
 
#define __RAISE_1( I ) \
   ImageVariant::Raise( static_cast<pcl::I&>( **this ), image )
 
#define __RAISE_2( I ) \
   image1 ^= static_cast<const pcl::I&>( *image2 )
 
private:
 
   template <class P> static
   void Raise( GenericImage<P>& image1, const ImageVariant& image2 )
   {
      SOLVE_TEMPLATE_2( image2, __RAISE_2 )
   }
 
public:
 
   ImageVariant& operator ^=( const ImageVariant& image )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __RAISE_1 )
      return *this;
   }
 
#undef __RAISE_1
#undef __RAISE_2
 
   // -------------------------------------------------------------------------
 
#define __INVERTED( I ) \
   result.SetImage( *new pcl::I( ~static_cast<const pcl::I&>( **this ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant operator ~() const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __INVERTED )
      return result;
   }
 
#undef __INVERTED
 
   // -------------------------------------------------------------------------
 
#define __OR( I ) \
   static_cast<pcl::I&>( **this ).Or( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Or( T scalar, const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __OR )
      return *this;
   }
 
#undef __OR
 
   // -------------------------------------------------------------------------
 
#define __OR_1( I ) \
   ImageVariant::Or( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __OR_2( I ) \
   image1.Or( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Or( GenericImage<P>& image1, const ImageVariant& image2,
            const Point& point, int channel,
            const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_REAL_2( image2, __OR_2 )
   }
 
public:
 
   ImageVariant& Or( const ImageVariant& image,
                     const Point& point = Point( int_max ), int channel = -1,
                     const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE_REAL( __OR_1 )
      return *this;
   }
 
#undef __OR_1
#undef __OR_2
 
   // -------------------------------------------------------------------------
 
#define __RAISE( I ) \
   static_cast<pcl::I&>( **this ).Raise( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Raise( T scalar,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __RAISE )
      return *this;
   }
 
#undef __RAISE
 
   template <typename T>
   ImageVariant& Pow( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Raise( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __Qn( I ) \
   result = static_cast<const pcl::I&>( **this ).Qn( rect, firstChannel, lastChannel, maxProcessors )
 
   double Qn( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
              int maxProcessors = 0 ) const
   {
      double result = false;
      if ( *this )
         SOLVE_TEMPLATE( __Qn )
      return result;
   }
 
#undef __Qn
 
   // -------------------------------------------------------------------------
 
#define __RAISE_1( I ) \
   ImageVariant::Raise( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __RAISE_2( I ) \
   image1.Raise( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Raise( GenericImage<P>& image1, const ImageVariant& image2,
               const Point& point, int channel,
               const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __RAISE_2 )
   }
 
public:
 
   ImageVariant& Raise( const ImageVariant& image,
                        const Point& point = Point( int_max ), int channel = -1,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __RAISE_1 )
      return *this;
   }
 
#undef __RAISE_1
#undef __RAISE_2
 
   ImageVariant& Pow( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __RAISED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Raised( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Raised( T scalar,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __RAISED )
      return result;
   }
 
#undef __RAISED
 
   // -------------------------------------------------------------------------
 
#define __READ( I ) \
   static_cast<pcl::I&>( **this ).Read( file )
 
   ImageVariant& Read( File& file )
   {
      if ( *this )
         SOLVE_TEMPLATE( __READ )
      return *this;
   }
 
#undef __READ
 
   // -------------------------------------------------------------------------
 
#define __READ( I ) \
   static_cast<pcl::I&>( **this ).Read( filePath )
 
   ImageVariant& Read( const String& filePath )
   {
      if ( *this )
         SOLVE_TEMPLATE( __READ )
      return *this;
   }
 
#undef __READ
 
   // -------------------------------------------------------------------------
 
#define __RESCALE( I ) \
   static_cast<pcl::I&>( **this ).Rescale( lowerBound, upperBound, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Rescale( T lowerBound, T upperBound,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __RESCALE )
      return *this;
   }
 
#undef __RESCALE
 
   // -------------------------------------------------------------------------
 
#define __RESCALE( I ) \
   static_cast<pcl::I&>( **this ).Rescale( rect, firstChannel, lastChannel )
 
   ImageVariant& Rescale( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __RESCALE )
      return *this;
   }
 
#undef __RESCALE
 
   // -------------------------------------------------------------------------
 
#define __RESCALED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Rescaled( lowerBound, upperBound, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Rescaled( T lowerBound, T upperBound,
                          const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __RESCALED )
      return result;
   }
 
#undef __RESCALED
 
   // -------------------------------------------------------------------------
 
#define __RESCALED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Rescaled( rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Rescaled( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE_REAL( __RESCALED )
      return result;
   }
 
#undef __RESCALED
 
   // -------------------------------------------------------------------------
 
#define __SET_ABSOLUTE_DIFFERENCE( I ) \
   static_cast<pcl::I&>( **this ).SetAbsoluteDifference( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& SetAbsoluteDifference( T scalar,
                                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SET_ABSOLUTE_DIFFERENCE )
      return *this;
   }
 
#undef __SET_ABSOLUTE_DIFFERENCE
 
   template <typename T>
   ImageVariant& Dif( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetAbsoluteDifference( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __SET_ABSOLUTE_DIFFERENCE_1( I ) \
   ImageVariant::SetAbsoluteDifference( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __SET_ABSOLUTE_DIFFERENCE_2( I ) \
   image1.SetAbsoluteDifference( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void SetAbsoluteDifference( GenericImage<P>& image1, const ImageVariant& image2,
                               const Point& point, int channel,
                               const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __SET_ABSOLUTE_DIFFERENCE_2 )
   }
 
public:
 
   ImageVariant& SetAbsoluteDifference( const ImageVariant& image,
                                        const Point& point = Point( int_max ), int channel = -1,
                                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __SET_ABSOLUTE_DIFFERENCE_1 )
      return *this;
   }
 
#undef __SET_ABSOLUTE_DIFFERENCE_1
#undef __SET_ABSOLUTE_DIFFERENCE_2
 
   ImageVariant& Dif( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __SET_ABSOLUTE_VALUE( I ) \
   static_cast<pcl::I&>( **this ).SetAbsoluteValue( rect, firstChannel, lastChannel )
 
   ImageVariant& SetAbsoluteValue( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SET_ABSOLUTE_VALUE )
      return *this;
   }
 
   ImageVariant& Abs( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetAbsoluteValue( rect, firstChannel, lastChannel );
   }
 
#undef __SET_ABSOLUTE_VALUE
 
   // -------------------------------------------------------------------------
 
#define __SET_COLOR_SPACE( I ) \
   static_cast<pcl::I&>( **this ).SetColorSpace( colorSpace, maxProcessors )
 
   ImageVariant& SetColorSpace( color_space colorSpace, int maxProcessors = 0 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SET_COLOR_SPACE )
      return *this;
   }
 
#undef __SET_COLOR_SPACE
 
   // -------------------------------------------------------------------------
 
#define __SET_COLUMN( I ) \
   static_cast<pcl::I&>( **this ).SetColumn( buffer, x, channel )
 
   template <typename T>
   ImageVariant& SetColumn( const T* buffer, int x, int channel = -1 )
   {
      PCL_PRECONDITION( buffer != 0 )
      if ( *this )
         SOLVE_TEMPLATE( __SET_COLUMN )
      return *this;
   }
 
#undef __SET_COLUMN
 
   // -------------------------------------------------------------------------
 
#define __SET_LIGHTNESS_1( I ) \
   ImageVariant::SetLightness( static_cast<pcl::I&>( **this ), L, point, rect, maxProcessors )
 
#define __SET_LIGHTNESS_2( I ) \
   image.SetLightness( static_cast<const pcl::I&>( *L ), point, rect, maxProcessors )
 
private:
 
   template <class P> static
   void SetLightness( GenericImage<P>& image, const ImageVariant& L,
                      const Point& point, const Rect& rect, int maxProcessors )
   {
      if ( !L.IsComplexSample() )
         SOLVE_TEMPLATE_REAL_2( L, __SET_LIGHTNESS_2 )
   }
 
public:
 
   ImageVariant& SetLightness( const ImageVariant& L,
                               const Point& point = Point( int_max ),
                               const Rect& rect = Rect( 0 ), int maxProcessors = 0 )
   {
      if ( *this )
         if ( !IsComplexSample() )
            if ( L )
               SOLVE_TEMPLATE_REAL( __SET_LIGHTNESS_1 )
      return *this;
   }
 
#undef __SET_LIGHTNESS_1
#undef __SET_LIGHTNESS_2
 
   // -------------------------------------------------------------------------
 
#define __SET_LUMINANCE_1( I ) \
   ImageVariant::SetLuminance( static_cast<pcl::I&>( **this ), Y, point, rect, maxProcessors )
 
#define __SET_LUMINANCE_2( I ) \
   image.SetLuminance( static_cast<const pcl::I&>( *Y ), point, rect, maxProcessors )
 
private:
 
   template <class P> static
   void SetLuminance( GenericImage<P>& image, const ImageVariant& Y,
                      const Point& point, const Rect& rect, int maxProcessors )
   {
      if ( !Y.IsComplexSample() )
         SOLVE_TEMPLATE_REAL_2( Y, __SET_LUMINANCE_2 )
   }
 
public:
 
   ImageVariant& SetLuminance( const ImageVariant& Y,
                               const Point& point = Point( int_max ),
                               const Rect& rect = Rect( 0 ), int maxProcessors = 0 )
   {
      if ( *this )
         if ( !IsComplexSample() )
            if ( Y )
               SOLVE_TEMPLATE_REAL( __SET_LUMINANCE_1 )
      return *this;
   }
 
#undef __SET_LUMINANCE_1
#undef __SET_LUMINANCE_2
 
   // -------------------------------------------------------------------------
 
#define __SET_MAXIMUM( I ) \
   static_cast<pcl::I&>( **this ).SetMaximum( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& SetMaximum( T scalar,
                             const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SET_MAXIMUM )
      return *this;
   }
 
#undef __SET_MAXIMUM
 
   template <typename T>
   ImageVariant& Max( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetMaximum( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __SET_MAXIMUM_1( I ) \
   ImageVariant::SetMaximum( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __SET_MAXIMUM_2( I ) \
   image1.SetMaximum( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void SetMaximum( GenericImage<P>& image1, const ImageVariant& image2,
                    const Point& point, int channel,
                    const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __SET_MAXIMUM_2 )
   }
 
public:
 
   ImageVariant& SetMaximum( const ImageVariant& image,
                             const Point& point = Point( int_max ), int channel = -1,
                             const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __SET_MAXIMUM_1 )
      return *this;
   }
 
#undef __SET_MAXIMUM_1
#undef __SET_MAXIMUM_2
 
   ImageVariant& Max( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __SET_MINIMUM( I ) \
   static_cast<pcl::I&>( **this ).SetMinimum( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& SetMinimum( T scalar,
                             const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SET_MINIMUM )
      return *this;
   }
 
#undef __SET_MINIMUM
 
   template <typename T>
   ImageVariant& Min( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return SetMinimum( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __SET_MINIMUM_1( I ) \
   ImageVariant::SetMinimum( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __SET_MINIMUM_2( I ) \
   image1.SetMinimum( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void SetMinimum( GenericImage<P>& image1, const ImageVariant& image2,
                    const Point& point, int channel,
                    const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __SET_MINIMUM_2 )
   }
 
public:
 
   ImageVariant& SetMinimum( const ImageVariant& image,
                             const Point& point = Point( int_max ), int channel = -1,
                             const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __SET_MINIMUM_1 )
      return *this;
   }
 
#undef __SET_MINIMUM_1
#undef __SET_MINIMUM_2
 
   ImageVariant& Min( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __Sn( I ) \
   result = static_cast<const pcl::I&>( **this ).Sn( rect, firstChannel, lastChannel, maxProcessors )
 
   double Sn( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
              int maxProcessors = 0 ) const
   {
      double result = false;
      if ( *this )
         SOLVE_TEMPLATE( __Sn )
      return result;
   }
 
#undef __Sn
 
   // -------------------------------------------------------------------------
 
#define __SET_ROW( I ) \
   static_cast<pcl::I&>( **this ).SetRow( buffer, y, channel )
 
   template <typename T>
   ImageVariant& SetRow( const T* buffer, int y, int channel = -1 )
   {
      PCL_PRECONDITION( buffer != 0 )
      if ( *this )
         SOLVE_TEMPLATE( __SET_ROW )
      return *this;
   }
 
#undef __SET_ROW
 
   // -------------------------------------------------------------------------
 
#define __ENSURE_UNIQUE_IMAGE( I ) \
   static_cast<pcl::I&>( **this ).EnsureUnique()
 
   ImageVariant& EnsureUniqueImage()
   {
      if ( *this )
         SOLVE_TEMPLATE( __ENSURE_UNIQUE_IMAGE )
      return *this;
   }
 
#undef __ENSURE_UNIQUE_IMAGE
 
   // -------------------------------------------------------------------------
 
#define __ENSURE_LOCAL_IMAGE( I ) \
   static_cast<pcl::I&>( **this ).EnsureLocal()
 
   ImageVariant& EnsureLocalImage()
   {
      if ( *this )
         SOLVE_TEMPLATE( __ENSURE_LOCAL_IMAGE )
      return *this;
   }
 
#undef __ENSURE_LOCAL_IMAGE
 
   // -------------------------------------------------------------------------
 
#define __SHIFT( I ) \
   static_cast<pcl::I&>( **this ).Shift( fillValues )
 
   template <typename T>
   ImageVariant& Shift( const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT )
      return *this;
   }
 
#undef __SHIFT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT( I ) \
   static_cast<pcl::I&>( **this ).Shift()
 
   ImageVariant& Shift()
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT )
      return *this;
   }
 
#undef __SHIFT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_BY( I ) \
   static_cast<pcl::I&>( **this ).ShiftBy( dx, dy, fillValues )
 
   template <typename T>
   ImageVariant& ShiftBy( int dx, int dy, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_BY )
      return *this;
   }
 
#undef __SHIFT_BY
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_BY( I ) \
   static_cast<pcl::I&>( **this ).ShiftBy( dx, dy )
 
   ImageVariant& ShiftBy( int dx, int dy )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_BY )
      return *this;
   }
 
#undef __SHIFT_BY
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO( I ) \
   static_cast<pcl::I&>( **this ).ShiftTo( x, y, fillValues )
 
   template <typename T>
   ImageVariant& ShiftTo( int x, int y, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO )
      return *this;
   }
 
#undef __SHIFT_TO
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO( I ) \
   static_cast<pcl::I&>( **this ).ShiftTo( x, y )
 
   ImageVariant& ShiftTo( int x, int y )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO )
      return *this;
   }
 
#undef __SHIFT_TO
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO( I ) \
   static_cast<pcl::I&>( **this ).ShiftTo( p, fillValues )
 
   template <typename T>
   ImageVariant& ShiftTo( const Point& p, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO )
      return *this;
   }
 
#undef __SHIFT_TO
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO( I ) \
   static_cast<pcl::I&>( **this ).ShiftTo( p )
 
   ImageVariant& ShiftTo( const Point& p )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO )
      return *this;
   }
 
#undef __SHIFT_TO
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_BOTTOM_LEFT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToBottomLeft( width, height, fillValues )
 
   template <typename T>
   ImageVariant& ShiftToBottomLeft( int width, int height, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_BOTTOM_LEFT )
      return *this;
   }
 
#undef __SHIFT_TO_BOTTOM_LEFT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_BOTTOM_LEFT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToBottomLeft( width, height )
 
   ImageVariant& ShiftToBottomLeft( int width, int height )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_BOTTOM_LEFT )
      return *this;
   }
 
#undef __SHIFT_TO_BOTTOM_LEFT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_BOTTOM_RIGHT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToBottomRight( width, height, fillValues )
 
   template <typename T>
   ImageVariant& ShiftToBottomRight( int width, int height, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_BOTTOM_RIGHT )
      return *this;
   }
 
#undef __SHIFT_TO_BOTTOM_RIGHT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_BOTTOM_RIGHT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToBottomRight( width, height )
 
   ImageVariant& ShiftToBottomRight( int width, int height )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_BOTTOM_RIGHT )
      return *this;
   }
 
#undef __SHIFT_TO_BOTTOM_RIGHT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_BOTTOM_CENTER( I ) \
   static_cast<pcl::I&>( **this ).ShiftToCenter( width, height, fillValues )
 
   template <typename T>
   ImageVariant& ShiftToCenter( int width, int height, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_BOTTOM_CENTER )
      return *this;
   }
 
#undef __SHIFT_TO_BOTTOM_CENTER
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_BOTTOM_CENTER( I ) \
   static_cast<pcl::I&>( **this ).ShiftToCenter( width, height )
 
   ImageVariant& ShiftToCenter( int width, int height )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_BOTTOM_CENTER )
      return *this;
   }
 
#undef __SHIFT_TO_BOTTOM_CENTER
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_TOP_LEFT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToTopLeft( width, height, fillValues )
 
   template <typename T>
   ImageVariant& ShiftToTopLeft( int width, int height, const GenericVector<T>& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_TOP_LEFT )
      return *this;
   }
 
#undef __SHIFT_TO_TOP_LEFT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_TOP_LEFT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToTopLeft( width, height )
 
   ImageVariant& ShiftToTopLeft( int width, int height )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_TOP_LEFT )
      return *this;
   }
 
#undef __SHIFT_TO_TOP_LEFT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_TOP_RIGHT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToTopRight( width, height, fillValues )
 
   template <typename T>
   ImageVariant& ShiftToTopRight( int width, int height, const GenericVector< T >& fillValues )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_TOP_RIGHT )
      return *this;
   }
 
#undef __SHIFT_TO_TOP_RIGHT
 
   // -------------------------------------------------------------------------
 
#define __SHIFT_TO_TOP_RIGHT( I ) \
   static_cast<pcl::I&>( **this ).ShiftToTopRight( width, height )
 
   ImageVariant& ShiftToTopRight( int width, int height )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SHIFT_TO_TOP_RIGHT )
      return *this;
   }
 
#undef __SHIFT_TO_TOP_RIGHT
 
   // -------------------------------------------------------------------------
 
#define __STD_DEV( I ) \
   result = static_cast<const pcl::I&>( **this ).StdDev( rect, firstChannel, lastChannel, maxProcessors )
 
   double StdDev( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                  int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __STD_DEV )
      return result;
   }
 
#undef __STD_DEV
 
   // -------------------------------------------------------------------------
 
#define __SUBTRACT( I ) \
   static_cast<pcl::I&>( **this ).Subtract( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Subtract( T scalar,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE( __SUBTRACT )
      return *this;
   }
 
#undef __SUBTRACT
 
   template <typename T>
   ImageVariant& Sub( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      return Subtract( scalar, rect, firstChannel, lastChannel );
   }
 
   // -------------------------------------------------------------------------
 
#define __SUBTRACT_1( I ) \
   ImageVariant::Subtract( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __SUBTRACT_2( I ) \
   image1.Subtract( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Subtract( GenericImage<P>& image1, const ImageVariant& image2,
                  const Point& point, int channel,
                  const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_2( image2, __SUBTRACT_2 )
   }
 
public:
 
   ImageVariant& Subtract( const ImageVariant& image,
                           const Point& point = Point( int_max ), int channel = -1,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __SUBTRACT_1 )
      return *this;
   }
 
#undef __SUBTRACT_1
#undef __SUBTRACT_2
 
   ImageVariant& Sub( const ImageVariant& 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 );
   }
 
   // -------------------------------------------------------------------------
 
#define __SUBTRACTED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Subtracted( scalar, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Subtracted( T scalar,
                            const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __SUBTRACTED )
      return result;
   }
 
#undef __SUBTRACTED
 
   // -------------------------------------------------------------------------
 
#define __SUM_OF_SQUARES( I ) \
   result = static_cast<const pcl::I&>( **this ).SumOfSquares( rect, firstChannel, lastChannel, maxProcessors )
 
   double SumOfSquares( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1,
                        int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __SUM_OF_SQUARES )
      return result;
   }
 
#undef __SUM_OF_SQUARES
 
   // -------------------------------------------------------------------------
 
#define __TRANSFER_IMAGE_1( I ) \
   ImageVariant::TransferImage( static_cast<pcl::I&>( **this ), image )
 
#define __TRANSFER_IMAGE_2( I ) \
   image1.Transfer( static_cast<pcl::I&>( *image2 ) )
 
private:
 
   template <class P> static
   void TransferImage( GenericImage<P>& image1, ImageVariant& image2 )
   {
      SOLVE_TEMPLATE_2( image2, __TRANSFER_IMAGE_2 )
   }
 
public:
 
   ImageVariant& TransferImage( ImageVariant& image )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE( __TRANSFER_IMAGE_1 )
      return *this;
   }
 
#undef __TRANSFER_IMAGE_1
#undef __TRANSFER_IMAGE_2
 
   // -------------------------------------------------------------------------
 
#define __TRANSFORM( I ) \
   static_cast<const pcl::I&>( **this ).Transform( transform, rect, firstChannel, lastChannel )
 
   void Transform( BidirectionalImageTransformation& transform,
                   const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      if ( *this )
         SOLVE_TEMPLATE( __TRANSFORM )
   }
 
#undef __TRANSFORM
 
   // -------------------------------------------------------------------------
 
#define __TRUNCATE( I ) \
   static_cast<pcl::I&>( **this ).Truncate( lowerBound, upperBound, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Truncate( T lowerBound, T upperBound,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __TRUNCATE )
      return *this;
   }
 
#undef __TRUNCATE
 
   // -------------------------------------------------------------------------
 
#define __TRUNCATE( I ) \
   static_cast<pcl::I&>( **this ).Truncate( rect, firstChannel, lastChannel )
 
   ImageVariant& Truncate( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __TRUNCATE )
      return *this;
   }
 
#undef __TRUNCATE
 
   // -------------------------------------------------------------------------
 
#define __TRUNCATED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Truncated( lowerBound, upperBound, rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   template <typename T>
   ImageVariant Truncated( T lowerBound, T upperBound,
                           const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __TRUNCATED )
      return result;
   }
 
#undef __TRUNCATED
 
   // -------------------------------------------------------------------------
 
#define __TRUNCATED( I ) \
   result.SetImage( *new pcl::I( static_cast<const pcl::I&>( **this ).Truncated( rect, firstChannel, lastChannel ) ) ); \
   result.SetOwnership( true )
 
   ImageVariant Truncated( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      ImageVariant result;
      if ( *this )
         SOLVE_TEMPLATE( __TRUNCATED )
      return result;
   }
 
#undef __TRUNCATED
 
   // -------------------------------------------------------------------------
 
#define __VARIANCE( I ) \
   result = static_cast<const pcl::I&>( **this ).Variance( rect, firstChannel, lastChannel, maxProcessors )
 
   double Variance( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1, int maxProcessors = 0 ) const
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __VARIANCE )
      return result;
   }
 
#undef __VARIANCE
 
   // -------------------------------------------------------------------------
 
#define __WHITE( I ) \
   static_cast<pcl::I&>( **this ).White( rect, firstChannel, lastChannel )
 
   ImageVariant& White( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __WHITE )
      return *this;
   }
 
#undef __WHITE
 
   // -------------------------------------------------------------------------
 
#define __WRITE( I ) \
   static_cast<const pcl::I&>( **this ).Write( file, rect, firstChannel, lastChannel )
 
   ImageVariant& Write( File& file,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      if ( *this )
         SOLVE_TEMPLATE( __WRITE )
      return const_cast<ImageVariant&>( *this );
   }
 
#undef __WRITE
 
   // -------------------------------------------------------------------------
 
#define __WRITE( I ) \
   static_cast<const pcl::I&>( **this ).Write( filePath, rect, firstChannel, lastChannel )
 
   ImageVariant& Write( const String& filePath,
                        const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 ) const
   {
      if ( *this )
         SOLVE_TEMPLATE( __WRITE )
      return const_cast<ImageVariant&>( *this );
   }
 
#undef __WRITE
 
   // -------------------------------------------------------------------------
 
#define __XNOR( I ) \
   static_cast<pcl::I&>( **this ).Xnor( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Xnor( T scalar,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __XNOR )
      return *this;
   }
 
#undef __XNOR
 
   // -------------------------------------------------------------------------
 
#define __XNOR_1( I ) \
   ImageVariant::Xnor( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __XNOR_2( I ) \
   image1.Xnor( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Xnor( GenericImage<P>& image1, const ImageVariant& image2,
              const Point& point, int channel,
              const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_REAL_2( image2, __XNOR_2 )
   }
 
public:
 
   ImageVariant& Xnor( const ImageVariant& image,
                       const Point& point = Point( int_max ), int channel = -1,
                       const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE_REAL( __XNOR_1 )
      return *this;
   }
 
#undef __XNOR_1
#undef __XNOR_2
 
   // -------------------------------------------------------------------------
 
#define __XOR( I ) \
   static_cast<pcl::I&>( **this ).Xor( scalar, rect, firstChannel, lastChannel )
 
   template <typename T>
   ImageVariant& Xor( T scalar,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __XOR )
      return *this;
   }
 
#undef __XOR
 
   // -------------------------------------------------------------------------
 
#define __XOR_1( I ) \
   ImageVariant::Xor( static_cast<pcl::I&>( **this ), image, point, channel, rect, firstChannel, lastChannel )
 
#define __XOR_2( I ) \
   image1.Xor( static_cast<const pcl::I&>( *image2 ), point, channel, rect, firstChannel, lastChannel )
 
private:
 
   template <class P> static
   void Xor( GenericImage<P>& image1, const ImageVariant& image2,
             const Point& point, int channel,
             const Rect& rect, int firstChannel, int lastChannel )
   {
      SOLVE_TEMPLATE_REAL_2( image2, __XOR_2 )
   }
 
public:
 
   ImageVariant& Xor( const ImageVariant& image,
                      const Point& point = Point( int_max ), int channel = -1,
                      const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         if ( image )
            SOLVE_TEMPLATE_REAL( __XOR_1 )
      return *this;
   }
 
#undef __XOR_1
#undef __XOR_2
 
   // -------------------------------------------------------------------------
 
#define __ZERO( I ) \
   static_cast<pcl::I&>( **this ).Zero( rect, firstChannel, lastChannel )
 
   ImageVariant& Zero( const Rect& rect = Rect( 0 ), int firstChannel = -1, int lastChannel = -1 )
   {
      if ( *this )
         SOLVE_TEMPLATE_REAL( __ZERO )
      return *this;
   }
 
#undef __ZERO
 
   // -------------------------------------------------------------------------
 
#define __COMPRESS( I ) \
   return static_cast<const pcl::I&>( **this ).Compress( compressor, rect, channel, perf )
 
   Compression::subblock_list Compress( const Compression& compressor,
                                        const Rect& rect = Rect( 0 ), int channel = -1,
                                        Compression::Performance* perf = nullptr ) const
   {
      if ( *this )
         SOLVE_TEMPLATE( __COMPRESS )
      return Compression::subblock_list();
   }
 
#undef __COMPRESS
 
   // -------------------------------------------------------------------------
 
   template <class P>
   bool IsAs( const pcl::GenericImage<P>& ) const
   {
      return m_data->image && m_data->isFloatSample == P::IsFloatSample() &&
                              m_data->isComplexSample == P::IsComplexSample() &&
                              m_data->bitsPerSample == P::BitsPerSample();
   }
 
   ImageVariant& Assign( const ImageVariant& image )
   {
      image.m_data->Attach();
      DetachFromData();
      m_data = image.m_data;
      return *this;
   }
 
   ImageVariant& operator =( const ImageVariant& image )
   {
      return Assign( image );
   }
 
#define TRANSFER_BODY()                                                                      \
   if ( &image != this ) /* N.B.: Self-movement incompatible with server-side SharedImage */ \
   {                                                                                         \
      DetachFromData();                                                                      \
      m_data = image.m_data;                                                                 \
      image.m_data = nullptr;                                                                \
   }                                                                                         \
   return *this
 
   ImageVariant& Transfer( ImageVariant& image )
   {
      TRANSFER_BODY();
   }
 
   ImageVariant& Transfer( ImageVariant&& image )
   {
      TRANSFER_BODY();
   }
 
#undef TRANSFER_BODY
 
   ImageVariant& operator =( ImageVariant&& image )
   {
      return Transfer( image );
   }
 
   void ReleaseTo( ImageVariant& image )
   {
      if ( &image != this ) // N.B.: Self-release incompatible with server-side SharedImage.
      {
         Data* newData = new Data;
         image.DetachFromData();
         image.m_data = m_data;
         m_data = newData;
      }
   }
 
   template <class P>
   ImageVariant& SetImage( GenericImage<P>& image )
   {
      if ( &image != m_data->image )
      {
         Free();
         m_data->Update( &image );
      }
      return *this;
   }
 
   friend void Swap( ImageVariant& x1, ImageVariant& x2 ) noexcept
   {
      pcl::Swap( x1.m_data, x2.m_data );
   }
 
   ImageVariant& CreateImage( bool isFloat, bool isComplex, int bitSize )
   {
      if ( isFloat )
      {
         if ( isComplex )
            CreateComplexImage( bitSize );
         else
            CreateFloatImage( bitSize );
      }
      else
      {
         if ( !isComplex )
            CreateUIntImage( bitSize );
         /*
         else
         {
            ### Yeah this is true, but everybody already knows so we don't want
                to replicate this useless message everywhere!
            throw Error( "Integer-valued complex images not supported by this PCL version." );
         }
         */
      }
 
      return *this;
   }
 
#define CREATE_IMAGE( I )  m_data->Update( new pcl::I )
 
   ImageVariant& CreateFloatImage( int bitSize = 32 )
   {
      PCL_PRECONDITION( bitSize == 32 || bitSize == 64 )
      Free();
      switch ( bitSize )
      {
      case 32: CREATE_IMAGE( Image ); break;
      case 64: CREATE_IMAGE( DImage ); break;
      }
      m_data->ownsImage = m_data->image != nullptr;
      return *this;
   }
 
   ImageVariant& CreateImage()
   {
      return CreateFloatImage();
   }
 
   ImageVariant& CreateComplexImage( int bitSize = 32 )
   {
      PCL_PRECONDITION( bitSize == 32 || bitSize == 64 )
      Free();
      switch ( bitSize )
      {
      case 32: CREATE_IMAGE( ComplexImage ); break;
      case 64: CREATE_IMAGE( DComplexImage ); break;
      }
      m_data->ownsImage = m_data->image != nullptr;
      return *this;
   }
 
   ImageVariant& CreateUIntImage( int bitSize = 16 )
   {
      PCL_PRECONDITION( bitSize == 8 || bitSize == 16 || bitSize == 32 )
      Free();
      switch ( bitSize )
      {
      case  8: CREATE_IMAGE( UInt8Image ); break;
      case 16: CREATE_IMAGE( UInt16Image ); break;
      case 32: CREATE_IMAGE( UInt32Image ); break;
      }
      m_data->ownsImage = m_data->image != nullptr;
      return *this;
   }
 
#undef CREATE_IMAGE
 
   template <class P>
   ImageVariant& CreateImageAs( const pcl::GenericImage<P>& image )
   {
      return CreateImage( P::IsFloatSample(), P::IsComplexSample(), P::BitsPerSample() );
   }
 
   ImageVariant& CreateImageAs( const ImageVariant& image )
   {
      return CreateImage( image.IsFloatSample(), image.IsComplexSample(), image.BitsPerSample() );
   }
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
   ImageVariant& CreateSharedImage( bool isFloat, bool isComplex, int bitSize )
   {
      if ( isFloat )
      {
         if ( isComplex )
            CreateSharedComplexImage( bitSize );
         else
            CreateSharedFloatImage( bitSize );
      }
      else
      {
         if ( !isComplex )
            CreateSharedUIntImage( bitSize );
      }
 
      return *this;
   }
 
#define CREATE_SHARED_IMAGE( I ) m_data->Update( new pcl::I( (void*)0, 0, 0 ) )
 
   ImageVariant& CreateSharedFloatImage( int bitSize = 32 )
   {
      PCL_PRECONDITION( bitSize == 32 || bitSize == 64 )
      Free();
      switch ( bitSize )
      {
      case 32: CREATE_SHARED_IMAGE( Image ); break;
      case 64: CREATE_SHARED_IMAGE( DImage ); break;
      }
      m_data->ownsImage = m_data->image != nullptr;
      return *this;
   }
 
   ImageVariant& CreateSharedImage()
   {
      return CreateSharedFloatImage();
   }
 
   ImageVariant& CreateSharedComplexImage( int bitSize = 32 )
   {
      PCL_PRECONDITION( bitSize == 32 || bitSize == 64 )
      Free();
      switch ( bitSize )
      {
      case 32: CREATE_SHARED_IMAGE( ComplexImage ); break;
      case 64: CREATE_SHARED_IMAGE( DComplexImage ); break;
      }
      m_data->ownsImage = m_data->image != nullptr;
      return *this;
   }
 
   ImageVariant& CreateSharedUIntImage( int bitSize = 16 )
   {
      PCL_PRECONDITION( bitSize == 8 || bitSize == 16 || bitSize == 32 )
      Free();
      switch ( bitSize )
      {
      case  8: CREATE_SHARED_IMAGE( UInt8Image ); break;
      case 16: CREATE_SHARED_IMAGE( UInt16Image ); break;
      case 32: CREATE_SHARED_IMAGE( UInt32Image ); break;
      }
      m_data->ownsImage = m_data->image != nullptr;
      return *this;
   }
 
#undef CREATE_SHARED_IMAGE
 
   template <class P>
   ImageVariant& CreateSharedImageAs( const pcl::GenericImage<P>& image )
   {
      return CreateSharedImage( P::IsFloatSample(), P::IsComplexSample(), P::BitsPerSample() );
   }
 
   ImageVariant& CreateSharedImageAs( const ImageVariant& image )
   {
      return CreateSharedImage( image.IsFloatSample(), image.IsComplexSample(), image.BitsPerSample() );
   }
 
#endif // !__PCL_BUILDING_PIXINSIGHT_APPLICATION
 
#define ALLOCATE_IMAGE( I ) \
   static_cast<pcl::I&>( **this ).AllocateData( width, height, numberOfChannels, colorSpace )
 
   ImageVariant& AllocateImage( int width, int height, int numberOfChannels, color_space colorSpace )
   {
      if ( !*this )
         CreateImage();
      SOLVE_TEMPLATE( ALLOCATE_IMAGE )
      return *this;
   }
 
#undef ALLOCATE_IMAGE
 
#define COPY_IMAGE( I ) static_cast<pcl::I&>( **this ).Assign( image )
 
   template <class P>
   ImageVariant& CopyImage( const GenericImage<P>& image )
   {
      if ( !*this )
         CreateImageAs( image );
      SOLVE_TEMPLATE( COPY_IMAGE )
      return *this;
   }
 
#undef COPY_IMAGE
 
#define COPY_IMAGE( I ) CopyImage( static_cast<const pcl::I&>( *image ) )
 
   ImageVariant& CopyImage( const ImageVariant& image )
   {
      if ( image )
         SOLVE_TEMPLATE_2( image, COPY_IMAGE )
      else
         FreeImage();
      return *this;
   }
 
#undef COPY_IMAGE
 
#define FREE_IMAGE( I ) static_cast<pcl::I&>( **this ).FreeData()
 
   ImageVariant& FreeImage()
   {
      if ( *this )
         SOLVE_TEMPLATE( FREE_IMAGE )
      return *this;
   }
 
   static Compression* NewCompression( swap_compression algorithm, int itemSize = 1 );
 
#undef FREE_IMAGE
 
   void WriteSwapFile( const String& filePath,
                       swap_compression compression = SwapCompression::None,
                       Compression::Performance* perf = nullptr,
                       bool processEvents = false ) const;
 
   void WriteSwapFiles( const String& fileName, const StringList& directories,
                        swap_compression compression = SwapCompression::None,
                        Compression::Performance* perf = nullptr,
                        bool processEvents = false ) const;
   void ReadSwapFile( const String& filePath,
                      Compression::Performance* perf = nullptr,
                      bool processEvents = false );
 
   void ReadSwapFiles( const String& fileName, const StringList& directories,
                       Compression::Performance* perf = nullptr,
                       bool processEvents = false );
 
   void MaskFromSwapFile( const String& filePath, const ImageVariant& mask, bool invert = false,
                          bool processEvents = false );
 
   void MaskFromSwapFiles( const String& fileName, const StringList& directories,
                           const ImageVariant& mask, bool invert = false,
                           bool processEvents = false );
 
   static void DeleteSwapFile( const String& filePath );
 
   static void DeleteSwapFiles( const String& fileName, const StringList& directories );
 
   static uint64 SwapFileSize( const String& filePath );
 
   static uint64 SwapFilesSize( const String& fileName, const StringList& directories );
 
   void MaskImage( const ImageVariant& src, const ImageVariant& mask, bool invert = false );
 
   bool OwnsImage() const noexcept
   {
      return m_data->ownsImage;
   }
 
   ImageVariant& SetOwnership( bool owner = true ) noexcept
   {
      m_data->ownsImage = owner && m_data->image;
      return *this;
   }
 
   ImageVariant& Free()
   {
      if ( m_data->IsUnique() )
         m_data->Free();
      else
      {
         Data* newData = new Data;
         DetachFromData();
         m_data = newData;
      }
      return *this;
   }
 
   const AbstractImage* operator ->() const noexcept
   {
      PCL_PRECONDITION( m_data->image != nullptr )
      return m_data->image;
   }
 
   AbstractImage* operator ->() noexcept
   {
      PCL_PRECONDITION( m_data->image != nullptr )
      return m_data->image;
   }
 
   const AbstractImage& operator *() const noexcept
   {
      PCL_PRECONDITION( m_data->image != nullptr )
      return *m_data->image;
   }
 
   AbstractImage& operator *() noexcept
   {
      PCL_PRECONDITION( m_data->image != nullptr )
      return *m_data->image;
   }
 
   operator bool() const noexcept
   {
      return m_data->image != nullptr;
   }
 
#define __PIXEL_ACCESS_OPERATOR( I ) \
   pcl::I::pixel_traits::FromSample( result, *static_cast<const pcl::I&>( **this ).PixelAddress( x, y, channel ) )
 
   double operator ()( int x, int y, int channel = 0 ) const noexcept
   {
      double result = 0;
      if ( *this )
         SOLVE_TEMPLATE( __PIXEL_ACCESS_OPERATOR )
      return result;
   }
 
#undef __PIXEL_ACCESS_OPERATOR
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
   bool IsShared() const noexcept
   {
      return m_shared != nullptr;
   }
 
   const pi::SharedImage* SharedImage() const
   {
      return m_shared;
   }
 
   // Implemented in SharedImage.cpp
   pi::SharedImage* GetSharedImage( bool rdOnly = false ) const;
   pi::SharedImage* NewSharedImage( void* owner, bool rdOnly = false );
 
#endif
 
private:
 
   struct Data : public ReferenceCounter
   {
      AbstractImage* image           = nullptr;
      bool           isFloatSample   = false;
      bool           isComplexSample = false;
      uint8          bitsPerSample   = 0;
      bool           ownsImage       = false;
 
      Data() = default;
 
      ~Data()
      {
         Free();
      }
 
      template <class P>
      void Update( GenericImage<P>* a_image ) noexcept
      {
         image = a_image;
         isFloatSample = P::IsFloatSample();
         isComplexSample = P::IsComplexSample();
         bitsPerSample = uint8( P::BitsPerSample() );
      }
 
      void Free()
      {
         if ( ownsImage )
            delete image;
         image = nullptr;
         isFloatSample = isComplexSample = false;
         bitsPerSample = 0;
         //ownsImage = ownsImage; ### N.B.: Ownership must *not* change here
      }
   };
 
   Data* m_data = nullptr;
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
   // This is the server-side part of the image sharing mechanism
   pi::SharedImage* m_shared = nullptr;
#else
   const void*      m_shared = nullptr;
#endif
 
   void DetachFromData()
   {
      if ( !m_data->Detach() )
         delete m_data;
   }
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
   // Server-side private ctor. used by View
   template <class P>
   ImageVariant( GenericImage<P>* image, int )
   {
      m_data = new Data;
      m_data->Update( image );
      m_data->ownsImage = true;
   }
#endif
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
   friend class pi::SharedImage;
#else
   friend class View;
   friend class ImageView;
#endif
};
 
// ----------------------------------------------------------------------------
 
/*
 * Implementation of member functions of GenericImage requiring a full
 * declaration of ImageVariant.
 */
 
template <class P> inline
void GenericImage<P>::GetLuminance( ImageVariant& Y, const Rect& rect, int maxProcessors ) const
{
   ImageVariant( const_cast<GenericImage<P>*>( this ) ).GetLuminance( Y, rect, maxProcessors );
}
 
template <class P> inline
void GenericImage<P>::GetLightness( ImageVariant& L, const Rect& rect, int maxProcessors ) const
{
   ImageVariant( const_cast<GenericImage<P>*>( this ) ).GetLightness( L, rect, maxProcessors );
}
 
template <class P> inline
void GenericImage<P>::GetIntensity( ImageVariant& I, const Rect& rect, int maxProcessors ) const
{
   ImageVariant( const_cast<GenericImage<P>*>( this ) ).GetIntensity( I, rect, maxProcessors );
}
 
template <class P> inline
GenericImage<P>& GenericImage<P>::SetLuminance( const ImageVariant& Y, const Point& point, const Rect& rect, int maxProcessors )
{
   (void)ImageVariant( this ).SetLuminance( Y, point, rect, maxProcessors );
   return *this;
}
 
template <class P> inline
GenericImage<P>& GenericImage<P>::SetLightness( const ImageVariant& L, const Point& point, const Rect& rect, int maxProcessors )
{
   (void)ImageVariant( this ).SetLightness( L, point, rect, maxProcessors );
   return *this;
}
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_ImageVariant_h
 
// ----------------------------------------------------------------------------
// EOF pcl/ImageVariant.h - Released 2024-06-18T15:48:54Z