FFTRegistration.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/FFTRegistration.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_FFTRegistration_h
#define __PCL_FFTRegistration_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/ImageVariant.h>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS FFTRegistrationEngine
{
public:
 
   FFTRegistrationEngine() = default;
 
   FFTRegistrationEngine( const FFTRegistrationEngine& ) = default;
 
   FFTRegistrationEngine( FFTRegistrationEngine&& x )
      : m_fftReference( std::move( x.m_fftReference ) )
   {
   }
 
   virtual ~FFTRegistrationEngine()
   {
   }
 
   bool IsInitialized() const
   {
      return !m_fftReference.IsEmpty();
   }
 
   template <class P>
   void Initialize( const pcl::GenericImage<P>& image )
   {
      Reset();
      m_fftReference = DoInitialize( image );
   }
 
   void Initialize( const ImageVariant& image )
   {
      Reset();
      if ( image )
         if ( image.IsComplexSample() )
            switch ( image.BitsPerSample() )
            {
            case 32: m_fftReference = DoInitialize( static_cast<const ComplexImage&>( *image ) ); break;
            case 64: m_fftReference = DoInitialize( static_cast<const DComplexImage&>( *image ) ); break;
            }
         else if ( image.IsFloatSample() )
            switch ( image.BitsPerSample() )
            {
            case 32: m_fftReference = DoInitialize( static_cast<const Image&>( *image ) ); break;
            case 64: m_fftReference = DoInitialize( static_cast<const DImage&>( *image ) ); break;
            }
         else
            switch ( image.BitsPerSample() )
            {
            case  8: m_fftReference = DoInitialize( static_cast<const UInt8Image&>( *image ) ); break;
            case 16: m_fftReference = DoInitialize( static_cast<const UInt16Image&>( *image ) ); break;
            case 32: m_fftReference = DoInitialize( static_cast<const UInt32Image&>( *image ) ); break;
            }
   }
 
   const ComplexImage& DFTOfReferenceImage() const
   {
      return m_fftReference;
   }
 
   void Reset()
   {
      m_fftReference.FreeData();
   }
 
   template <class P>
   void Evaluate( const pcl::GenericImage<P>& image )
   {
      PCL_PRECONDITION( IsInitialized() )
      if ( IsInitialized() )
         DoEvaluate( image );
   }
 
   void Evaluate( const ImageVariant& image )
   {
      PCL_PRECONDITION( IsInitialized() )
      if ( IsInitialized() )
         if ( image )
            if ( image.IsComplexSample() )
               switch ( image.BitsPerSample() )
               {
               case 32: DoEvaluate( static_cast<const pcl::ComplexImage&>( *image ) ); break;
               case 64: DoEvaluate( static_cast<const pcl::DComplexImage&>( *image ) ); break;
               }
            else if ( image.IsFloatSample() )
               switch ( image.BitsPerSample() )
               {
               case 32: DoEvaluate( static_cast<const pcl::Image&>( *image ) ); break;
               case 64: DoEvaluate( static_cast<const pcl::DImage&>( *image ) ); break;
               }
            else
               switch ( image.BitsPerSample() )
               {
               case  8: DoEvaluate( static_cast<const pcl::UInt8Image&>( *image ) ); break;
               case 16: DoEvaluate( static_cast<const pcl::UInt16Image&>( *image ) ); break;
               case 32: DoEvaluate( static_cast<const pcl::UInt32Image&>( *image ) ); break;
               }
   }
 
protected:
 
   // DFT of the reference image.
   ComplexImage m_fftReference;
 
   virtual ComplexImage DoInitialize( const pcl::Image& ) = 0;
   virtual ComplexImage DoInitialize( const pcl::DImage& ) = 0;
   virtual ComplexImage DoInitialize( const pcl::ComplexImage& ) = 0;
   virtual ComplexImage DoInitialize( const pcl::DComplexImage& ) = 0;
   virtual ComplexImage DoInitialize( const pcl::UInt8Image& ) = 0;
   virtual ComplexImage DoInitialize( const pcl::UInt16Image& ) = 0;
   virtual ComplexImage DoInitialize( const pcl::UInt32Image& ) = 0;
 
   virtual void DoEvaluate( const pcl::Image& ) = 0;
   virtual void DoEvaluate( const pcl::DImage& ) = 0;
   virtual void DoEvaluate( const pcl::ComplexImage& ) = 0;
   virtual void DoEvaluate( const pcl::DComplexImage& ) = 0;
   virtual void DoEvaluate( const pcl::UInt8Image& ) = 0;
   virtual void DoEvaluate( const pcl::UInt16Image& ) = 0;
   virtual void DoEvaluate( const pcl::UInt32Image& ) = 0;
};
 
// ----------------------------------------------------------------------------
 
template <class O> inline
FFTRegistrationEngine& operator <<( FFTRegistrationEngine& R, const O& image )
{
   if ( !R.IsInitialized() )
      R.Initialize( image );
   else
      R.Evaluate( image );
   return R;
}
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS FFTTranslation : public FFTRegistrationEngine
{
public:
 
   FFTTranslation() = default;
 
   ~FFTTranslation() override
   {
   }
 
   bool AreLargeTranslationsEnabled() const
   {
      return m_largeTranslations;
   }
 
   void EnableLargeTranslations( bool enable = true )
   {
      if ( enable != m_largeTranslations )
      {
         Reset();
         m_largeTranslations = enable;
      }
   }
 
   void DisableLargeTranslations( bool disable = true )
   {
      EnableLargeTranslations( !disable );
   }
 
   const FPoint& Delta() const
   {
      return m_delta;
   }
 
   float DeltaX() const
   {
      return m_delta.x;
   }
 
   float DeltaY() const
   {
      return m_delta.y;
   }
 
   float Peak() const
   {
      return m_peak;
   }
 
protected:
 
   // Allow translations > size/2.
   // Warning: a lot of memory may be necessary --four times more.
   bool     m_largeTranslations = false;
 
   // Evaluation result.
   FPoint   m_delta = 0.0F;
 
   // Peak value detected in the phase matrix.
   float    m_peak = 0.0F;
 
   ComplexImage DoInitialize( const pcl::Image& ) override;
   ComplexImage DoInitialize( const pcl::DImage& ) override;
   ComplexImage DoInitialize( const pcl::ComplexImage& ) override;
   ComplexImage DoInitialize( const pcl::DComplexImage& ) override;
   ComplexImage DoInitialize( const pcl::UInt8Image& ) override;
   ComplexImage DoInitialize( const pcl::UInt16Image& ) override;
   ComplexImage DoInitialize( const pcl::UInt32Image& ) override;
 
   void DoEvaluate( const pcl::Image& ) override;
   void DoEvaluate( const pcl::DImage& ) override;
   void DoEvaluate( const pcl::ComplexImage& ) override;
   void DoEvaluate( const pcl::DComplexImage& ) override;
   void DoEvaluate( const pcl::UInt8Image& ) override;
   void DoEvaluate( const pcl::UInt16Image& ) override;
   void DoEvaluate( const pcl::UInt32Image& ) override;
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS FFTRotationAndScaling : public FFTRegistrationEngine
{
public:
 
   FFTRotationAndScaling() = default;
 
   ~FFTRotationAndScaling() override
   {
   }
 
   bool EvaluatesScaling() const
   {
      return m_evaluateScaling;
   }
 
   void EnableScalingEvaluation( bool enable = true )
   {
      if ( enable != m_evaluateScaling )
      {
         Reset();
         m_evaluateScaling = enable;
      }
   }
 
   void DisableScalingEvaluation( bool disable = true )
   {
      EnableScalingEvaluation( !disable );
   }
 
   float LowFrequencyCutoff() const
   {
      return m_lowFrequencyCutoff;
   }
 
   bool HasLowFrequencyCutoff() const
   {
      return LowFrequencyCutoff() > 0;
   }
 
   void SetLowFrequencyCutoff( float r )
   {
      m_lowFrequencyCutoff = Range( r, 0.0F, 0.5F );
   }
 
   float RotationAngle() const
   {
      return m_rotationAngle;
   }
 
   float ScalingRatio() const
   {
      return m_scalingRatio;
   }
 
protected:
 
   // Evaluate rotation+scaling, or just rotation?
   bool     m_evaluateScaling = false;
 
   // Low-frequency cutoff, as a fraction of the DFT radius.
   float    m_lowFrequencyCutoff = 1.0F/200;
 
   // Evaluation result
   float    m_rotationAngle = 0.0F; // radians
   float    m_scalingRatio = 1.0F;  // pixels
 
   ComplexImage DoInitialize( const pcl::Image& ) override;
   ComplexImage DoInitialize( const pcl::DImage& ) override;
   ComplexImage DoInitialize( const pcl::ComplexImage& ) override;
   ComplexImage DoInitialize( const pcl::DComplexImage& ) override;
   ComplexImage DoInitialize( const pcl::UInt8Image& ) override;
   ComplexImage DoInitialize( const pcl::UInt16Image& ) override;
   ComplexImage DoInitialize( const pcl::UInt32Image& ) override;
 
   void DoEvaluate( const pcl::Image& ) override;
   void DoEvaluate( const pcl::DImage& ) override;
   void DoEvaluate( const pcl::ComplexImage& ) override;
   void DoEvaluate( const pcl::DComplexImage& ) override;
   void DoEvaluate( const pcl::UInt8Image& ) override;
   void DoEvaluate( const pcl::UInt16Image& ) override;
   void DoEvaluate( const pcl::UInt32Image& ) override;
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_FFTRegistration_h
 
// ----------------------------------------------------------------------------
// EOF pcl/FFTRegistration.h - Released 2024-06-18T15:48:54Z