PixelInterpolation.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/PixelInterpolation.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_PixelInterpolation_h
#define __PCL_PixelInterpolation_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/AutoPointer.h>
#include <pcl/BicubicFilterInterpolation.h>
#include <pcl/BicubicInterpolation.h>
#include <pcl/BilinearInterpolation.h>
#include <pcl/Exception.h>
#include <pcl/LanczosInterpolation.h>
#include <pcl/NearestNeighborInterpolation.h>
#include <pcl/PixelTraits.h>
#include <pcl/Point.h>
#include <pcl/String.h>
 
#ifdef _MSC_VER
#  pragma warning( push )
#  pragma warning( disable : 4267 )  // conversion from 'size_t' to ...
#endif
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS PixelInterpolation
{
public:
 
   template <class P>
   class PCL_CLASS Interpolator
   {
   public:
 
      using sample = typename P::sample;
 
      Interpolator( BidimensionalInterpolation<sample>* interpolation,
                    const sample* data, int width, int height, bool unclipped = false )
         : m_interpolation( interpolation )
         , m_unclipped( unclipped )
      {
         if ( !m_interpolation.IsNull() )
            m_interpolation->Initialize( data, width, height );
      }
 
      Interpolator( const Interpolator& ) = delete;
 
      Interpolator( Interpolator&& ) = default;
 
      virtual ~Interpolator()
      {
      }
 
      const BidimensionalInterpolation<sample>& Interpolation() const
      {
         PCL_PRECONDITION( !m_interpolation.IsNull() )
         return *m_interpolation;
      }
 
      BidimensionalInterpolation<sample>& Interpolation()
      {
         PCL_PRECONDITION( !m_interpolation.IsNull() )
         return *m_interpolation;
      }
 
      sample operator()( double x, double y ) const
      {
         PCL_PRECONDITION( !m_interpolation.IsNull() )
         double r = (*m_interpolation)( x, y );
         if ( !m_unclipped )
         {
            if ( r > P::MaxSampleValue() )
               return P::MaxSampleValue();
            if ( r < P::MinSampleValue() )
               return P::MinSampleValue();
         }
         return P::FloatToSample( r );
      }
 
      template <typename T>
      sample operator()( const GenericPoint<T>& p ) const
      {
         return operator()( p.x, p.y );
      }
 
   private:
 
      AutoPointer<BidimensionalInterpolation<sample>> m_interpolation;
                                                 bool m_unclipped;
   };
 
   // -------------------------------------------------------------------------
 
   PixelInterpolation() = default;
 
   PixelInterpolation( const PixelInterpolation& ) = default;
 
   virtual ~PixelInterpolation()
   {
   }
 
   virtual String Description() const = 0;
 
   virtual bool IsThreadSafe() const
   {
      return true;
   }
 
   template <class P, class T>
   Interpolator<P>* NewInterpolator( const T* data, int width, int height, bool unclipped = false ) const
   {
      return new Interpolator<P>( NewInterpolation( data ), data, width, height, unclipped );
   }
 
protected:
 
   virtual BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 32-bit floating point images" );
   }
 
   virtual BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 64-bit floating point images" );
   }
 
   virtual BidimensionalInterpolation<ComplexPixelTraits::sample>*
                  NewInterpolation( const ComplexPixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 32-bit complex images" );
   }
 
   virtual BidimensionalInterpolation<DComplexPixelTraits::sample>*
                  NewInterpolation( const DComplexPixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 64-bit complex images" );
   }
 
   virtual BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 8-bit integer images" );
   }
 
   virtual BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 16-bit integer images" );
   }
 
   virtual BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const
   {
      throw NotImplemented( *this, "Interpolate 32-bit integer images" );
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS NearestNeighborPixelInterpolation : public PixelInterpolation
{
public:
 
   NearestNeighborPixelInterpolation() = default;
 
   NearestNeighborPixelInterpolation( const NearestNeighborPixelInterpolation& ) = default;
 
   String Description() const override
   {
      return "Nearest neighbor interpolation";
   }
 
private:
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new NearestNeighborInterpolation<FloatPixelTraits::sample>;
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new NearestNeighborInterpolation<DoublePixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new NearestNeighborInterpolation<UInt8PixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new NearestNeighborInterpolation<UInt16PixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new NearestNeighborInterpolation<UInt32PixelTraits::sample>;
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS BilinearPixelInterpolation : public PixelInterpolation
{
public:
 
   BilinearPixelInterpolation() = default;
 
   BilinearPixelInterpolation( const BilinearPixelInterpolation& ) = default;
 
   String Description() const override
   {
      return "Bilinear interpolation";
   }
 
private:
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new BilinearInterpolation<FloatPixelTraits::sample>;
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new BilinearInterpolation<DoublePixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new BilinearInterpolation<UInt8PixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new BilinearInterpolation<UInt16PixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new BilinearInterpolation<UInt32PixelTraits::sample>;
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS BicubicSplinePixelInterpolation : public PixelInterpolation
{
public:
 
   BicubicSplinePixelInterpolation( double clamp = __PCL_BICUBIC_SPLINE_CLAMPING_THRESHOLD )
      : m_clamp( clamp )
   {
   }
 
   BicubicSplinePixelInterpolation( const BicubicSplinePixelInterpolation& ) = default;
 
   String Description() const override
   {
      return String().Format( "Bicubic spline interpolation, c=%.2f", m_clamp );
   }
 
private:
 
   float m_clamp;
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new BicubicSplineInterpolation<FloatPixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new BicubicSplineInterpolation<DoublePixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new BicubicSplineInterpolation<UInt8PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new BicubicSplineInterpolation<UInt16PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new BicubicSplineInterpolation<UInt32PixelTraits::sample>( m_clamp );
   }
};
 
class PCL_CLASS BicubicPixelInterpolation : public BicubicSplinePixelInterpolation
{
public:
 
   BicubicPixelInterpolation( double c = __PCL_BICUBIC_SPLINE_CLAMPING_THRESHOLD )
      : BicubicSplinePixelInterpolation( c )
   {
   }
 
   BicubicPixelInterpolation( const BicubicPixelInterpolation& ) = default;
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS BicubicBSplinePixelInterpolation : public PixelInterpolation
{
public:
 
   BicubicBSplinePixelInterpolation() = default;
 
   BicubicBSplinePixelInterpolation( const BicubicBSplinePixelInterpolation& ) = default;
 
   String Description() const override
   {
      return "Bicubic B-spline interpolation";
   }
 
private:
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new BicubicBSplineInterpolation<FloatPixelTraits::sample>;
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new BicubicBSplineInterpolation<DoublePixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new BicubicBSplineInterpolation<UInt8PixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new BicubicBSplineInterpolation<UInt16PixelTraits::sample>;
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new BicubicBSplineInterpolation<UInt32PixelTraits::sample>;
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS BicubicFilterPixelInterpolation : public PixelInterpolation
{
public:
 
   BicubicFilterPixelInterpolation( int rh, int rv, const CubicFilter& filter )
      : m_rh( Max( 1, rh ) )
      , m_rv( Max( 1, rv ) )
   {
      PCL_PRECONDITION( rh >= 1 )
      PCL_PRECONDITION( rv >= 1 )
      m_filter = filter.Clone();
   }
 
   BicubicFilterPixelInterpolation( const BicubicFilterPixelInterpolation& x )
      : m_rh( x.m_rh )
      , m_rv( x.m_rv )
   {
      m_filter = x.m_filter->Clone();
   }
 
   BicubicFilterPixelInterpolation( BicubicFilterPixelInterpolation&& ) = default;
 
   ~BicubicFilterPixelInterpolation() override
   {
   }
 
   String Description() const override
   {
      return "Bicubic interpolation, " + m_filter->Description().AppendFormat( " (%dx%d)", 2*m_rh + 1, 2*m_rv + 1 );
   }
 
   const CubicFilter& Filter() const
   {
      return *m_filter;
   }
 
private:
 
   int                      m_rh, m_rv;
   AutoPointer<CubicFilter> m_filter;
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new BicubicFilterInterpolation<FloatPixelTraits::sample>( m_rh, m_rv, *m_filter );
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new BicubicFilterInterpolation<DoublePixelTraits::sample>( m_rh, m_rv, *m_filter );
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new BicubicFilterInterpolation<UInt8PixelTraits::sample>( m_rh, m_rv, *m_filter );
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new BicubicFilterInterpolation<UInt16PixelTraits::sample>( m_rh, m_rv, *m_filter );
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new BicubicFilterInterpolation<UInt32PixelTraits::sample>( m_rh, m_rv, *m_filter );
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS LanczosPixelInterpolation : public PixelInterpolation
{
public:
 
   LanczosPixelInterpolation( int n = 3, float clamp = 0.3 )
      : m_n( Max( 1, n ) )
      , m_clamp( clamp )
   {
      PCL_PRECONDITION( n >= 1 )
      PCL_PRECONDITION( clamp < 0 || 0 <= clamp && clamp <= 1 )
   }
 
   LanczosPixelInterpolation( const LanczosPixelInterpolation& ) = default;
 
   String Description() const override
   {
      String desc = String().Format( "Lanczos-%d interpolation", m_n );
      if ( m_clamp >= 0 )
         desc.AppendFormat( ", c=%.2f", m_clamp );
      return desc;
   }
 
private:
 
   int   m_n;     // filter order
   float m_clamp; // clamping threshold (enabled if >= 0)
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new LanczosInterpolation<FloatPixelTraits::sample>( m_n, m_clamp );
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new LanczosInterpolation<DoublePixelTraits::sample>( m_n, m_clamp );
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new LanczosInterpolation<UInt8PixelTraits::sample>( m_n, m_clamp );
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new LanczosInterpolation<UInt16PixelTraits::sample>( m_n, m_clamp );
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new LanczosInterpolation<UInt32PixelTraits::sample>( m_n, m_clamp );
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Lanczos3LUTPixelInterpolation : public PixelInterpolation
{
public:
 
   Lanczos3LUTPixelInterpolation( float clamp = 0.3F )
      : m_clamp( clamp )
   {
      PCL_PRECONDITION( clamp < 0 || 0 <= clamp && clamp <= 1 )
   }
 
   Lanczos3LUTPixelInterpolation( const Lanczos3LUTPixelInterpolation& ) = default;
 
   String Description() const override
   {
      String desc( "Lanczos-3 LUT interpolation" );
      if ( m_clamp >= 0 )
         desc.AppendFormat( ", c=%.2f", m_clamp );
      return desc;
   }
 
private:
 
   float m_clamp; // clamping threshold (enabled if >= 0)
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new Lanczos3LUTInterpolation<FloatPixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new Lanczos3LUTInterpolation<DoublePixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new Lanczos3LUTInterpolation<UInt8PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new Lanczos3LUTInterpolation<UInt16PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new Lanczos3LUTInterpolation<UInt32PixelTraits::sample>( m_clamp );
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Lanczos4LUTPixelInterpolation : public PixelInterpolation
{
public:
 
   Lanczos4LUTPixelInterpolation( float clamp = 0.3F )
      : m_clamp( Range( clamp, 0.0F, 1.0F ) )
   {
      PCL_PRECONDITION( clamp < 0 || 0 <= clamp && clamp <= 1 )
   }
 
   Lanczos4LUTPixelInterpolation( const Lanczos4LUTPixelInterpolation& ) = default;
 
   String Description() const override
   {
      String desc( "Lanczos-4 LUT interpolation" );
      if ( m_clamp >= 0 )
         desc.AppendFormat( ", c=%.2f", m_clamp );
      return desc;
   }
 
private:
 
   float m_clamp; // clamping threshold (enabled if >= 0)
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new Lanczos4LUTInterpolation<FloatPixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new Lanczos4LUTInterpolation<DoublePixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new Lanczos4LUTInterpolation<UInt8PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new Lanczos4LUTInterpolation<UInt16PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new Lanczos4LUTInterpolation<UInt32PixelTraits::sample>( m_clamp );
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Lanczos5LUTPixelInterpolation : public PixelInterpolation
{
public:
 
   Lanczos5LUTPixelInterpolation( float clamp = 0.3F )
      : m_clamp( Range( clamp, 0.0F, 1.0F ) )
   {
      PCL_PRECONDITION( clamp < 0 || 0 <= clamp && clamp <= 1 )
   }
 
   Lanczos5LUTPixelInterpolation( const Lanczos5LUTPixelInterpolation& ) = default;
 
   String Description() const override
   {
      String desc( "Lanczos-5 LUT interpolation" );
      if ( m_clamp >= 0 )
         desc.AppendFormat( ", c=%.2f", m_clamp );
      return desc;
   }
 
private:
 
   float m_clamp; // clamping threshold (enabled if >= 0)
 
   BidimensionalInterpolation<FloatPixelTraits::sample>*
                  NewInterpolation( const FloatPixelTraits::sample* ) const override
   {
      return new Lanczos5LUTInterpolation<FloatPixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<DoublePixelTraits::sample>*
                  NewInterpolation( const DoublePixelTraits::sample* ) const override
   {
      return new Lanczos5LUTInterpolation<DoublePixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt8PixelTraits::sample>*
                  NewInterpolation( const UInt8PixelTraits::sample* ) const override
   {
      return new Lanczos5LUTInterpolation<UInt8PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt16PixelTraits::sample>*
                  NewInterpolation( const UInt16PixelTraits::sample* ) const override
   {
      return new Lanczos5LUTInterpolation<UInt16PixelTraits::sample>( m_clamp );
   }
 
   BidimensionalInterpolation<UInt32PixelTraits::sample>*
                  NewInterpolation( const UInt32PixelTraits::sample* ) const override
   {
      return new Lanczos5LUTInterpolation<UInt32PixelTraits::sample>( m_clamp );
   }
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#ifdef _MSC_VER
#  pragma warning( pop )
#endif
 
#endif   // __PCL_PixelInterpolation_h
 
// ----------------------------------------------------------------------------
// EOF pcl/PixelInterpolation.h - Released 2024-06-18T15:48:54Z