BackendSSIM.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "BackendBase.h"
#include "BackendConv2D.h"
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class FL_EXPORT CTensor;
 
        template <typename T>
        class FL_EXPORT CBackendSSIM : public CBackendBase<T>
        {
        public:
            CBackendSSIM();
            CBackendSSIM(const CBackendSSIM<T>& bs);
            virtual ~CBackendSSIM();
 
            virtual const CResult SetSSIMParameters(T tMaxDiffValue = (T)INFINITY, int64_t i64FilterSize = 11, T tFilterSigma = (T)1.5, T tK1 = (T)0.01, T tK2 = (T)0.03, bool bReturnIndexMap = false);
            virtual const CResult GetSSIMParameters(T& tMaxDiffValue, int64_t& i64FilterSize, T& tFilterSigma, T& tK1, T& tK2, bool& bReturnIndexMap);
 
            virtual const CResult SSIM(const CTensor<T>* pTsrInput1, const CTensor<T>* pTsrInput2, CTensor<T>* pTsrResult, CBackendConv2D<T>& backendConv2D, bool bTraining);
            virtual const CResult Backward(const CTensor<T>* pTsrInput1, const CTensor<T>* pTsrInput2, const CTensor<T>* pTsrDy, CTensor<T>* pTsrDx1, CTensor<T>* pTsrDx2, CBackendConv2D<T>& backendConv2D);
 
            virtual const int64_t GetRequiredTemporaryMemory_Forward(std::vector<int64_t>& vctInputShape) const;
            virtual const int64_t GetRequiredTemporaryMemory_Backward(std::vector<int64_t>& vctInputShape) const;
 
            virtual const int64_t GetRequiredDedicatedMemory(std::vector<int64_t>& vctInputShape, int64_t i64Channel) const;
 
            DeclareGetClassType();
            SupportToDuplicateObjectWithoutCreateNewObject(CBackendSSIM<T>, *this);
 
        protected:
            T m_tMaxDiff;
            int64_t m_i64FilterSize;
            T m_tFilterSigma;
            T m_tK1;
            T m_tK2;
            bool m_bReturnIndexMap;
 
            CTensor<T> m_tsrGaussianFilter;
 
            CTensor<T> m_tsrMeanX;
            CTensor<T> m_tsrMeanY;
            CTensor<T> m_tsrMap;
            CTensor<T> m_tsrA;
            CTensor<T> m_tsrB;
            CTensor<T> m_tsrC;
            CTensor<T> m_tsrD;
 
        protected:
            virtual const CResult CreateGaussianFilter(int64_t i64Channel);
            virtual const CResult Calculate_Forward();
            virtual const CResult Calculate_Backward(const CTensor<T>* pTsrDy, CTensor<T>* pTsrdB, CTensor<T>* pTsrdD, T tDivide);
            virtual const CResult Calculate_UpdateGradient(const CTensor<T>* pTsrInput1, const CTensor<T>* pTsrInput2, const CTensor<T>* pTsrDy, CTensor<T>* pTsrdB, CTensor<T>* pTsrdD, CTensor<T>* pTsrConvB, CTensor<T>* pTsrConvD, CTensor<T>* pTsrConvMu, CTensor<T>* pTsrdMu, CTensor<T>* pTsrDx, CBackendConv2D<T>& backendConv2D, T tDivide, bool bOpr1);
        };
    }
}
 
#endif