TensorImagesWithMaskLabels.h

#pragma once
 
#if _MSC_VER >= 1900 && defined(_M_X64)
 
#include "TensorImages.h"
 
#include <atomic>
#include <bitset>
 
namespace FLImaging
{
    namespace AI
    {
        template <typename T>
        class FL_EXPORT CTensorImagesWithMaskLabels : public CTensorImages<T>
        {
        public:
            CTensorImagesWithMaskLabels();
 
            CTensorImagesWithMaskLabels(const CTensorImagesWithMaskLabels<T>& tsr, bool bDeepCopy = true);
 
            virtual ~CTensorImagesWithMaskLabels();
 
            static const CResult GetClassNumFromImages(const Base::CFLImage* pFli, bool bMaskImage, Base::CFLArray<int32_t>& flaClassNum);
 
            virtual const CResult Create(const std::vector<int64_t>& vctShape, bool bOrderByDesc = true, bool bCudaAllocation = true) override;
            virtual const CResult Create(const Base::CFLImage* pFli, bool bNormalize = true, std::atomic<int32_t>* pI32CurrentPreparingTensorIndex = nullptr, bool* pBAbort = nullptr) override;
            virtual const CResult Create(const Base::CFLImage& fli, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod, bool bROIExtraction, bool bNormalize, const Base::CMultiVar<T>& mvBlankColor, ImageProcessing::EInterpolationMethod eInterpolationMethod, std::atomic<int32_t>* pI32CurrentPreparingTensorIndex, bool* pBAbort) override;
            virtual const CResult Create(const Base::CFLImage* pFli, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod, bool bROIExtraction, bool bNormalize, const Base::CMultiVar<T>& mvBlankColor, ImageProcessing::EInterpolationMethod eInterpolationMethod, std::atomic<int32_t>* pI32CurrentPreparingTensorIndex, bool* pBAbort) override;
            virtual const CResult Create(const Base::CFLImage& fli, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod = EResizeMethod_ScaleAllAxises, bool bROIExtraction = false, bool bNormalize = true, const Base::CMultiVar<T>& mvBlankColor = 0., ImageProcessing::EInterpolationMethod eInterpolationMethod = ImageProcessing::EInterpolationMethod_Bilinear, std::atomic<int32_t>* pI32CurrentPreparingTensorIndex = nullptr, std::atomic<int32_t>* pI32CurrentPreparingMaskIndex = nullptr, bool* pBAbort = nullptr);
            virtual const CResult Create(const Base::CFLImage* pFli, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod = EResizeMethod_ScaleAllAxises, bool bROIExtraction = false, bool bNormalize = true, const Base::CMultiVar<T>& mvBlankColor = 0., ImageProcessing::EInterpolationMethod eInterpolationMethod = ImageProcessing::EInterpolationMethod_Bilinear, std::atomic<int32_t>* pI32CurrentPreparingTensorIndex = nullptr, std::atomic<int32_t>* pI32CurrentPreparingMaskIndex = nullptr, bool* pBAbort = nullptr);
 
            virtual const CResult Create(const wchar_t* pWcFilePath, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod = EResizeMethod_ScaleAllAxises, bool bROIExtraction = false, bool bNormalize = true, const Base::CMultiVar<T>& mvBlankColor = 0., bool bRecursive = false, ImageProcessing::EInterpolationMethod eInterpolationMethod = ImageProcessing::EInterpolationMethod_Bilinear) override;
 
            virtual const CResult Assign(const CTensor<T>* pTsr, bool bDeepCopy = true) override;
            virtual const CResult Assign(const CTensorImages<T>* pTsr, bool bDeepCopy = true) override;
 
            virtual const CResult Assign(const CTensorImagesWithMaskLabels<T>& tsr, bool bDeepCopy = true);
            virtual const CResult Assign(const CTensorImagesWithMaskLabels<T>* pTsr, bool bDeepCopy = true);
 
            virtual const CResult Append(const Base::CFLImage* pFli, EResizeMethod eResizeMethod = EResizeMethod_ScaleAllAxises, bool bROIExtraction = false, bool bNormalize = true, const Base::CMultiVar<T>& mvBlankColor = 0., ImageProcessing::EInterpolationMethod eInterpolationMethod = ImageProcessing::EInterpolationMethod_Bilinear, std::atomic<int32_t>* pI32CurrentPreparingTensorIndex = nullptr, bool* pBAbort = nullptr) override;
 
            virtual const CResult Append(const wchar_t* pWcFilePath, bool bRecursive = false) override;
 
            virtual const CResult Clear() override;
 
            virtual const CResult SetMaskLabelImage(const Base::CFLImage& fliMaskLabelImage);
            virtual const CResult SetMaskLabelImage(const Base::CFLImage* pFliMaskLabelImage);
            virtual const Base::CFLImage* GetMaskLabelImage() const;
 
            virtual const CResult SetBatchParameters(const CTensorImages<T>& tsr) override;
            virtual const CResult SetBatchParameters(const CTensorImagesWithMaskLabels<T>& tsr);
 
            virtual CTensorImagesWithMaskLabels<T>& Evaluate() override;
            virtual CComputationalBase<T>* Clone() const override;
 
            virtual const CResult Swap(CComputationalBase<T>& cbSwap) override;
 
            virtual const CResult LoadTensor(const std::vector<int64_t>& vctBatchIndices) override;
            virtual const CResult CopyMaskLabels(CTensorImagesWithMaskLabels<T>* pTsrOrg, std::vector<int64_t>& vctOrders);
 
            virtual const Base::CFLImage* GetCurrentMaskLabels() const;
 
            virtual const CResult EnableMaskLabelImage(bool bEnable);
            virtual bool IsMaskLabelImageEnabled() const;
 
            virtual const CResult EnableMaskTensor(bool bEnable);
            virtual bool IsMaskTensorEnabled() const;
 
            virtual const CResult CreateLabelImage(const Base::CFLImage* pFliSrc, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod, bool bAppend = false, std::atomic<int32_t>* pI32CurrentPreparingMaskIndex = nullptr, bool* pBAbort = nullptr, Base::CFLImage* pFliDst = nullptr);
 
            virtual const CResult GetLabelRatio(std::vector<float>& vctLabelRatio);
            virtual const CResult GetLabelRatioSum(std::vector<float>& vctLabelRatioSum);
            virtual const CResult GetLabelCount(std::vector<int32_t>& vctLabelCount);
 
            virtual const CResult EnableLabelIncludingOutline(bool bEnable);
            virtual bool IsLabelIncludingOutlineEnabled() const;
 
            virtual const CResult SetLabelOutlineThickness(float f32Thickness);
            virtual float GetLabelOutlineThickness() const;
 
            virtual const CResult SetLabelIncludingContourNum(int32_t i32LabelNum);
            virtual int32_t GettLabelIncludingContourNum() const;
 
            virtual const CResult SetZeroLabelFigureConvertNum(int32_t i32LabelNum);
            virtual int32_t GetZeroLabelFigureConvertNum() const;
 
            DeclareGetClassType();
            SupportToDuplicateObject(CTensorImagesWithMaskLabels, *this);
 
        protected:
            virtual const CResult DecodeLabels(const wchar_t* pWcsImagePath, Base::CFLImage* pFli = nullptr);
            virtual const CResult MakeDistribution() override;
            virtual const CResult InternalCreateLabelImage(const std::vector<int64_t>& vctBatchIndices, const Base::CFLImage* pFliSrc, const std::vector<int64_t>& vctNewSize, EResizeMethod eResizeMethod, bool bAppend = false, std::atomic<int32_t>* pI32CurrentPreparingMaskIndex = nullptr, bool* pBAbort = nullptr, Base::CFLImage* pFliDst = nullptr);
            
        protected:
            Base::CFLImage* m_pFliMaskLabelImage;
            Base::CFLImage m_fliMaskLabels;
            Base::CFLImage m_fliCurrentMaskLabels;
            Base::CFLImage m_fliMaskLabelThreadBuffer;
 
            std::vector<float>& m_vctLabelRatio;
            std::vector<float>& m_vctLabelRatioSum;
            std::vector<int32_t>& m_vctLabelCount;
 
            std::bitset<1024>& m_bsLabels;
 
            bool m_bMaskTensor;
            bool m_bClearMaskLabel;
            bool m_bMaskImage;
            bool m_bLabelIncludingOutline;
            float m_f32LabelIncludingOutlineThickness;
            int32_t m_i32LabelIncludingContourNum;
            int32_t m_i32ZeroFigureLabel;
            int32_t m_i32ZeroLabelFigureConvertNum;
 
        private:
            template<typename T>
            friend class CClassEqualizerBase;
 
            template<typename T>
            friend class CClassEqualizerForTensorImagesWithMaskLabels;
 
            static CTensorImagesWithMaskLabels<T>* GetInstance();
        public:
            DeclareGetSignletonObject(CTensorImagesWithMaskLabels);
        };
 
        #define CCGFTensorLabelsWithMaskLabels(...) (*(new CTensorImagesWithMaskLabels<float>(__VA_ARGS__)))
        #define CCGDTensorLabelsWithMaskLabels(...) (*(new CTensorImagesWithMaskLabels<double>(__VA_ARGS__)))
 
        typedef CTensorImagesWithMaskLabels<float> CTensorImagesWithMaskLabelsF;
        typedef CTensorImagesWithMaskLabels<double> CTensorImagesWithMaskLabelsD;
    }
}
 
#endif