ATrousWaveletTransform.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.9.3
// ----------------------------------------------------------------------------
// pcl/ATrousWaveletTransform.h - Released 2025-02-21T12:13:32Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2025 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_ATrousWaveletTransform_h
#define __PCL_ATrousWaveletTransform_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/AutoPointer.h>
#include <pcl/KernelFilter.h>
#include <pcl/RedundantMultiscaleTransform.h>
#include <pcl/SeparableFilter.h>
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
namespace pi
{
   class PixInsightPerformanceAnalyzer;
}
#endif
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class InterlacedTransformation;
 
class PCL_CLASS ATrousWaveletTransform : public RedundantMultiscaleTransform
{
public:
 
   using layer = RedundantMultiscaleTransform::layer;
 
   using transform = RedundantMultiscaleTransform::transform;
 
   using layer_state_set = RedundantMultiscaleTransform::layer_state_set;
 
   struct WaveletScalingFunction
   {
      AutoPointer<KernelFilter>    kernelFilter;    
      AutoPointer<SeparableFilter> separableFilter; 
 
      WaveletScalingFunction() = default;
 
      WaveletScalingFunction( const KernelFilter& f )
      {
         kernelFilter = f.Clone();
         PCL_CHECK( !kernelFilter.IsNull() )
      }
 
      WaveletScalingFunction( const SeparableFilter& f )
      {
         separableFilter = f.Clone();
         PCL_CHECK( !separableFilter.IsNull() )
      }
 
      WaveletScalingFunction( const WaveletScalingFunction& s )
      {
         if ( !s.kernelFilter.IsNull() )
         {
            kernelFilter = s.kernelFilter->Clone();
            PCL_CHECK( !kernelFilter.IsNull() )
         }
         if ( !s.separableFilter.IsNull() )
         {
            separableFilter = s.separableFilter->Clone();
            PCL_CHECK( !separableFilter.IsNull() )
         }
      }
 
      WaveletScalingFunction( WaveletScalingFunction&& s )
         : kernelFilter( s.kernelFilter )
         , separableFilter( s.separableFilter )
      {
      }
 
      virtual ~WaveletScalingFunction()
      {
      }
 
      WaveletScalingFunction& operator =( const WaveletScalingFunction& s )
      {
         if ( s.kernelFilter.IsNull() )
            kernelFilter.Destroy();
         else
         {
            kernelFilter = s.kernelFilter->Clone();
            PCL_CHECK( !kernelFilter.IsNull() )
         }
 
         if ( s.separableFilter.IsNull() )
            separableFilter.Destroy();
         else
         {
            separableFilter = s.separableFilter->Clone();
            PCL_CHECK( !separableFilter.IsNull() )
         }
 
         return *this;
      }
 
      WaveletScalingFunction& operator =( WaveletScalingFunction&& ) = default;
 
      bool IsSeparable() const
      {
         return !separableFilter.IsNull() && !separableFilter->IsEmpty();
      }
 
      bool IsNonseparable() const
      {
         return !kernelFilter.IsNull() && !kernelFilter->IsEmpty();
      }
 
      bool IsValid() const
      {
         return IsSeparable() || IsNonseparable();
      }
 
      void Set( const KernelFilter& f )
      {
         separableFilter.Destroy();
         kernelFilter = f.Clone();
         PCL_CHECK( !kernelFilter.IsNull() )
      }
 
      void Set( const SeparableFilter& f )
      {
         kernelFilter.Destroy();
         separableFilter = f.Clone();
         PCL_CHECK( !separableFilter.IsNull() )
      }
 
      void Clear()
      {
         kernelFilter.Destroy();
         separableFilter.Destroy();
      }
 
      bool operator ==( const WaveletScalingFunction& other ) const
      {
         if ( !kernelFilter.IsNull() )
            return !other.kernelFilter.IsNull() && *kernelFilter == *other.kernelFilter;
         if ( !separableFilter.IsNull() )
            return !other.separableFilter.IsNull() && *separableFilter == *other.separableFilter;
         return other.kernelFilter.IsNull() && other.separableFilter.IsNull();
      }
   };
 
   ATrousWaveletTransform() = default;
 
   ATrousWaveletTransform( const WaveletScalingFunction& f, int n = 4, int d = 0 )
      : RedundantMultiscaleTransform( n, d )
      , m_scalingFunction( f )
   {
      PCL_CHECK( m_scalingFunction.IsValid() )
   }
 
   ATrousWaveletTransform( const KernelFilter& f, int n = 4, int d = 0 )
      : RedundantMultiscaleTransform( n, d )
      , m_scalingFunction( f )
   {
      PCL_CHECK( m_scalingFunction.IsValid() )
   }
 
   ATrousWaveletTransform( const SeparableFilter& f, int n = 4, int d = 0 )
      : RedundantMultiscaleTransform( n, d )
      , m_scalingFunction( f )
   {
      PCL_CHECK( m_scalingFunction.IsValid() )
   }
 
   ATrousWaveletTransform( const ATrousWaveletTransform& ) = default;
 
   ATrousWaveletTransform( ATrousWaveletTransform&& ) = default;
 
   virtual ~ATrousWaveletTransform()
   {
   }
 
   ATrousWaveletTransform& operator =( const ATrousWaveletTransform& ) = default;
 
   ATrousWaveletTransform& operator =( ATrousWaveletTransform&& ) = default;
 
   const WaveletScalingFunction& ScalingFunction() const
   {
      return m_scalingFunction;
   }
 
   void SetScalingFunction( const WaveletScalingFunction& f )
   {
      DestroyLayers();
      m_scalingFunction = f;
      PCL_CHECK( m_scalingFunction.IsValid() )
   }
 
   void SetScalingFunction( const KernelFilter& f )
   {
      DestroyLayers();
      m_scalingFunction.Set( f );
      PCL_CHECK( m_scalingFunction.IsValid() )
   }
 
   void SetScalingFunction( const SeparableFilter& f )
   {
      DestroyLayers();
      m_scalingFunction.Set( f );
      PCL_CHECK( m_scalingFunction.IsValid() )
   }
 
   double NoiseKSigma( int j = 0, float k = 3,
                       float eps = 0.01, int n = 10, size_type* N = nullptr ) const;
 
   double NoiseKSigma( int j, const ImageVariant& image,
                       float low = 0.00002F, float high = 0.99998F,
                       float k = 3, float eps = 0.01, int n = 10, size_type* N = nullptr ) const;
 
   double NoiseMRS( const ImageVariant& image, const float sj[],
                    double sigma = 0, float k = 3, size_type* N = nullptr,
                    float low = 0.00002F, float high = 0.99998F ) const;
 
private:
 
   /*
    * Wavelet scaling function.
    */
   WaveletScalingFunction m_scalingFunction;
 
   /*
    * Transform (decomposition)
    */
   void Transform( const pcl::Image& ) override;
   void Transform( const pcl::DImage& ) override;
   void Transform( const pcl::ComplexImage& ) override;
   void Transform( const pcl::DComplexImage& ) override;
   void Transform( const pcl::UInt8Image& ) override;
   void Transform( const pcl::UInt16Image& ) override;
   void Transform( const pcl::UInt32Image& ) override;
 
   void ValidateScalingFunction() const;
 
   double PCL_PA_NoiseMRS_F32( const Image&, const float [], double, int ) const;
   double PCL_PA_NoiseMRS_F64( const DImage&, const float [], double, int ) const;
 
   friend class ATWTDecomposition;
 
#ifdef __PCL_BUILDING_PIXINSIGHT_APPLICATION
   friend class pi::PixInsightPerformanceAnalyzer;
#endif
};
 
// ----------------------------------------------------------------------------
 
using StarletTransform = ATrousWaveletTransform;
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_ATrousWaveletTransform_h
 
// ----------------------------------------------------------------------------
// EOF pcl/ATrousWaveletTransform.h - Released 2025-02-21T12:13:32Z