AugmentationParameters.h

#pragma once
 
#include "DefinitionsAI.h"
#include "ObjectAugmentationParameters.h"
#ifdef _M_X64

 
#pragma pack(push, 1)

namespace FLImaging
{
    namespace AI
    {
        class FL_EXPORT CAugmentationParameters : public Base::CFLBase
        {
        public:
            enum EMixMethod
            {
                EMixMethod_None = 0,
                EMixMethod_RandomSelection,
                EMixMethod_MixUp,
                EMixMethod_CutMix,
                EMixMethod_Mosaic,
            };
 
        public:
            CAugmentationParameters();
            CAugmentationParameters(const CAugmentationParameters& ap);
            CAugmentationParameters(const CAugmentationParameters* pAp);
            virtual ~CAugmentationParameters();

            virtual const CResult Assign(const CAugmentationParameters& ap);
            virtual const CResult Assign(const CAugmentationParameters* pAp);

            const CAugmentationParameters& operator=(const CAugmentationParameters& ap);
            virtual const CResult Clear();
 
            virtual const CResult SetCommonActivationRate(double f64CommonActivationRate = 1.);
            virtual const CResult GetCommonActivationRate(double& f64CommonActivationRate) const;

            virtual const CResult SetCommonIoUThreshold(double f64CommonIoUThreshold);

            virtual const CResult GetCommonIoUThreshold(double& f64CommonIoUThreshold) const;

            virtual const CResult SetCommonInterpolationMethod(ImageProcessing::EInterpolationMethod eCommonInterpolationMethod = ImageProcessing::EInterpolationMethod_Bilinear);

            virtual const CResult GetCommonInterpolationMethod(ImageProcessing::EInterpolationMethod& eCommonInterpolationMethod) const;

            virtual const CResult SetCommonBlankColorMethod(EBlankColorMethod eCommonBlankColorMethod = EBlankColorMethod_ZeroPadding);

            virtual const CResult GetCommonBlankColorMethod(EBlankColorMethod& eCommonBlankColorMethod) const;
 
            virtual const CResult EnableAugmentation(bool bEnableAugmentation);
            virtual bool IsAugmentationEnabled() const;

            virtual const CResult EnableValidation(bool bEnableValidationAugmentation = true);
            virtual bool IsValidationEnabled() const;

            virtual const CResult EnableMixMethod(bool bMixMethod);
            virtual bool IsMixMethodEnabled() const;
            virtual const CResult SetMixMethodParam(EMixMethod eMixMethod = EMixMethod_None, double f64MixActivationRate = .8);
            virtual const CResult GetMixMethodParam(EMixMethod& eMixMethod, double& f64MixActivationRate) const;

            virtual const CResult SetMixUpParam(double f64MinMixUpBlendRatio = 0.4, double f64MaxMixUpBlendRatio = .6);
            virtual const CResult GetMixUpParam(double& f64MinMixUpBlendRatio, double& f64MaxMixUpBlendRatio) const;

            virtual const CResult SetCutMixParam(double f64MinCutMixRatioX = 0.1, double f64MaxCutMixRatioX = .4, double f64MinCutMixRatioY = 0.1, double f64MaxCutMixRatioY = .4, double f64MinCutMixBlendRatio = 0., double f64MaxCutMixBlendRatio = .0);
            virtual const CResult GetCutMixParam(double& f64MinCutMixRatioX, double& f64MaxCutMixRatioX, double& f64MinCutMixRatioY, double& f64MaxCutMixRatioY, double& f64MinCutMixBlendRatio, double& f64MaxCutMixBlendRatio) const;
            virtual const CResult EnableResizedCrop(bool bResizedCrop);
            virtual bool IsResizedCropEnabled() const;
            virtual const CResult SetResizedCropParam(double f64MinResizedCropScaleRatio = .8, double f64MaxResizedCropScaleRatio = 1.0, double f64MinResizedCropAspectRatio = 0.8, double f64MaxResizedCropAspectRatio = 1.25, double f64ResizedCropActivationRate = 1.);
            virtual const CResult GetResizedCropParam(double& f64MinResizedCropScaleRatio, double& f64MaxResizedCropScaleRatio, double& f64MinResizedCropAspectRatio, double& f64MaxResizedCropAspectRatio, double& f64ResizedCropActivationRate) const;

            virtual const CResult EnableHorizontalFlip(bool bFlip);
            virtual bool IsHorizontalFlipEnabled() const;
            virtual const CResult SetHorizontalFlipParam(double f64HorizontalFlipActivationRate = 1.);
            virtual const CResult GetHorizontalFlipParam(double& f64HorizontalFlipActivationRate) const;
            virtual const CResult EnableVerticalFlip(bool bFlip);
            virtual bool IsVerticalFlipEnabled() const;
            virtual const CResult SetVerticalFlipParam(double f64VerticalFlipActivationRate = 1.);
            virtual const CResult GetVerticalFlipParam(double& f64VerticalFlipActivationRate) const;

            virtual const CResult EnableAdjustment(bool bAdjustment);
            virtual bool IsAdjustmentEnabled() const;
            virtual const CResult SetAdjustmentParam(double f64MinAdjustmentBrightness = .8, double f64MaxAdjustmentBrightness = 1.25, double f64MinAdjustmentContrast = .8, double f64MaxAdjustmentContrast = 1.25, double f64AdjustmentActivationRate = 1.);
            virtual const CResult GetAdjustmentParam(double& f64MinAdjustmentBrightness, double& f64MaxAdjustmentBrightness, double& f64MinAdjustmentContrast, double& f64MaxAdjustmentContrast, double& f64AdjustmentActivationRate) const;

            virtual const CResult EnableIntensity(bool bIntensity);
            virtual bool IsIntensityEnabled() const;
            virtual const CResult SetIntensityParam(double f64MinSaturation = .8, double f64MaxSaturation = 1.25, double f64MinExposure = .8, double f64MaxExposure = 1.25, double f64MinHue = -0.03, double f64MaxHue = .03, double f64IntensityActivationRate = 1.);
            virtual const CResult GetIntensityParam(double& f64MinSaturation, double& f64MaxSaturation, double& f64MinExposure, double& f64MaxExposure, double& f64MinHue, double& f64MaxHue, double& f64IntensityActivationRate) const;

            virtual const CResult EnableGradation(bool bGradation);
            virtual bool IsGradationEnabled() const;
            virtual const CResult SetGradationParam(double f64GradationMinAlpha = 0., double f64GradationMaxAlpha = .1, double f64GradationActivationRate = 1.);
            virtual const CResult GetGradationParam(double& f64GradationMinAlpha, double& f64GradationMaxAlpha, double& f64GradationActivationRate) const;

            virtual const CResult EnableEmphasize(bool bEmphasize);
            virtual bool IsEmphasizeEnabled() const;
            virtual const CResult SetEmphasizeParam(int64_t i64MinimumKernelSize = 1, int64_t i64MaximumKernelSize = 3, double f64MinimumFactor = 0., double f64MaximumFactor = 1., double f64EmphasizeActivationRate = 1.);
            virtual const CResult GetEmphasizeParam(int64_t& i64MinimumKernelSize, int64_t& i64MaximumKernelSize, double& f64MinimumFactor, double& f64MaximumFactor, double& f64EmphasizeActivationRate) const;

            virtual const CResult EnableGaussianBlur(bool bGaussianBlur);
            virtual bool IsGaussianBlurEnabled() const;
            virtual const CResult SetGaussianBlurParam(int64_t i64MinKernelSize = 1, int64_t i64MaxKernelSize = 3, double f64GaussianBlurActivationRate = 1.);
            virtual const CResult GetGaussianBlurParam(int64_t& i64MinKernelSize, int64_t& i64MaxKernelSize, double& f64GaussianBlurActivationRate) const;

            virtual const CResult EnableGaussianNoise(bool bGaussianNoise);
            virtual bool IsGaussianNoiseEnabled() const;
            virtual const CResult SetGaussianNoiseParam(double f64MinMean = 0., double f64MaxMean = 0., double f64MinStdev = 0., double f64MaxStdev = .02, double f64GaussianNoiseActivationRate = 1.);
            virtual const CResult GetGaussianNoiseParam(double& f64MinMean, double& f64MaxMean, double& f64MinStdev, double& f64MaxStdev, double& f64GaussianNoiseActivationRate) const;

            virtual const CResult EnableAlphaBlendMask(bool bAlphaBlendMask);
            virtual bool IsAlphaBlendMaskEnabled() const;

            virtual const CResult SetAlphaBlendMaskParam(double f64MinAlphaBlendMaskRatioX = 0.05, double f64MaxAlphaBlendMaskRatioX = .1, double f64MinAlphaBlendMaskRatioY = 0.05, double f64MaxAlphaBlendMaskRatioY = .1, double f64MinAlphaBlendMaskValue = 0., double f64MaxAlphaBlendMaskValue = 1., double f64MinAlphaBlendMaskBlendRatio = 0.6, double f64MaxAlphaBlendMaskBlendRatio = 1., double f64AlphaBlendMaskActivationRate = .5, int64_t i64MinAlphaBlendMaskCount = 1, int64_t i64MaxAlphaBlendMaskCount = 2);
            virtual const CResult GetAlphaBlendMaskParam(double& f64MinAlphaBlendMaskRatioX, double& f64MaxAlphaBlendMaskRatioX, double& f64MinAlphaBlendMaskRatioY, double& f64MaxAlphaBlendMaskRatioY, double& f64MinAlphaBlendMaskValue, double& f64MaxAlphaBlendMaskValue, double& f64MinAlphaBlendMaskBlendRatio, double& f64MaxAlphaBlendMaskBlendRatio, double& f64AlphaBlendMaskActivationRate, int64_t& i64MinAlphaBlendMaskCount, int64_t& i64MaxAlphaBlendMaskCount) const;

            virtual const CResult EnablePerspective(bool bPerspective);
            virtual bool IsPerspectiveEnabled() const;
            virtual const CResult SetPerspectiveParam(double f64MinPerspectiveRatio = .0, double f64MaxPerspectiveRatio = .1, double f64PerspectiveActivationRate = 1.);
            virtual const CResult GetPerspectiveParam(double& f64MinPerspectiveRatio, double& f64MaxPerspectiveRatio, double& f64PerspectiveActivationRate) const;

            virtual const CResult EnableQuarterRotation(bool bQuarterRotation);
            virtual bool IsQuarterRotationEnabled() const;
            virtual const CResult SetQuarterRotationParam(bool bAngle0 = true, bool bAngle90 = true, bool bAngle180 = true, bool bAngle270 = true, double f64QuarterRotationActivationRate = 1.);
            virtual const CResult GetQuarterRotationParam(bool& bAngle0, bool& bAngle90, bool& bAngle180, bool& bAngle270, double& f64QuarterRotationActivationRate) const;

            virtual const CResult EnableRotation(bool bRotation);
            virtual bool IsRotationEnabled() const;
            virtual const CResult SetRotationParam(double f64MinAngle = -5., double f64MaxAngle = 5., bool bRectMode = false, bool bFitTensor = false, double f64RotationActivationRate = 1.);
            virtual const CResult GetRotationParam(double& f64MinAngle, double& f64MaxAngle, bool& bRectMode, bool& bFitTensor, double& f64RotationActivationRate) const;

            virtual const CResult EnableScale(bool bScale);
            virtual bool IsScaleEnabled() const;
            virtual const CResult SetScaleParam(double f64MinScaleRatioX = 0.98, double f64MaxScaleRatioX = 1.02, double f64MinScaleRatioY = 0.98, double f64MaxScaleRatioY = 1.02, bool bPreservingScaleRatio = true, double f64ScaleActivationRate = 1.);
            virtual const CResult GetScaleParam(double& f64MinScaleRatioX, double& f64MaxScaleRatioX, double& f64MinScaleRatioY, double& f64MaxScaleRatioY, bool& bPreservingScaleRatio, double& f64ScaleActivationRate) const;

            virtual const CResult EnableTranslation(bool bTranslation);
            virtual bool IsTranslationEnabled() const;
            virtual const CResult SetTranslationParam(double f64MinTranslationRatioX = -0.1, double f64MaxTranslationRatioX = 0.1, double f64MinTranslationRatioY = -0.1, double f64MaxTranslationRatioY = 0.1, double f64TranslationActivationRate = 1.);
            virtual const CResult GetTranslationParam(double& f64MinTranslationRatioX, double& f64MaxTranslationRatioX, double& f64MinTranslationRatioY, double& f64MaxTranslationRatioY, double& f64TranslationActivationRate) const;

            virtual const CResult EnableCutout(bool bCutout);
            virtual bool IsCutoutEnabled() const;
            virtual const CResult SetCutoutParam(double f64MinCutoutRatioX = 0.05, double f64MaxCutoutRatioX = .1, double f64MinCutoutRatioY = 0.05, double f64MaxCutoutRatioY = .1, double f64CutoutActivationRate = .5, int64_t i64MinCutoutCount = 1, int64_t i64MaxCutoutCount = 2);
            virtual const CResult GetCutoutParam(double& f64MinCutoutRatioX, double& f64MaxCutoutRatioX, double& f64MinCutoutRatioY, double& f64MaxCutoutRatioY, double& f64CutoutActivationRate, int64_t& i64MinCutoutCount, int64_t& i64MaxCutoutCount) const;
 
            virtual const CResult GetBinaryData(Base::CFLData& fldBinary, int32_t i32Version = -1) const;
            virtual const CResult GetBinaryData(Base::CFLData* pFldBinary, int32_t i32Version = -1) const;
 
            virtual const CResult SetBinaryData(const Base::CFLData& fldBinary);
            virtual const CResult SetBinaryData(const Base::CFLData* pFldBinary);
 
            DeclareGetClassType();
            SupportToDuplicateObjectWithoutCreateNewObject(CAugmentationParameters, *this);
            virtual const CResult SetObjectAugmentationParameters(CObjectAugmentationParameters objectAugmentationParameters);
            virtual const CObjectAugmentationParameters* GetObjectAugmentationParameters() const;
 
        protected:
            CObjectAugmentationParameters m_objectAugmentationParameters;
 
            bool m_bValidation;
            bool m_bAugmentation;
            double m_f64CommonActivationRate;
            double m_f64CommonIoUThreshold;
            ImageProcessing::EInterpolationMethod m_eCommonInterpolationMethod;
            EBlankColorMethod m_eCommonBlankColorMethod;

            bool m_bMixMethod;
            double m_f64MixActivationRate;
            EMixMethod m_eMixMethod;
            double m_f64MinMixUpBlendRatio;
            double m_f64MaxMixUpBlendRatio;

            double m_f64MinCutMixRatioX;
            double m_f64MaxCutMixRatioX;
            double m_f64MinCutMixRatioY;
            double m_f64MaxCutMixRatioY;
            double m_f64MinCutMixBlendRatio;
            double m_f64MaxCutMixBlendRatio;
            bool m_bResizedCrop;
            double m_f64ResizedCropActivationRate;
            double m_f64MinResizedCropScaleRatio;
            double m_f64MaxResizedCropScaleRatio;
            double m_f64MinResizedCropAspectRatio;
            double m_f64MaxResizedCropAspectRatio;

            bool m_bHorizontalFlip;
            double m_f64HorizontalFlipActivationRate;
            bool m_bVerticalFlip;
            double m_f64VerticalFlipActivationRate;

            bool m_bAdjustment;
            double m_f64AdjustmentActivationRate;
            double m_f64MinAdjustmentBrightness;
            double m_f64MaxAdjustmentBrightness;
            double m_f64MinAdjustmentContrast;
            double m_f64MaxAdjustmentContrast;

            bool m_bIntensity;
            double m_f64IntensityActivationRate;
            double m_f64MinSaturation;
            double m_f64MaxSaturation;
            double m_f64MinExposure;
            double m_f64MaxExposure;
            double m_f64MinHue;
            double m_f64MaxHue;

            bool m_bGradation;
            double m_f64GradationActivationRate;
            double m_f64GradationMinAlpha;
            double m_f64GradationMaxAlpha;

            bool m_bEmphasize;
            double m_f64EmphasizeActivationRate;
            int64_t m_i64MinEmphasizeKernelSize;
            int64_t m_i64MaxEmphasizeKernelSize;
            double m_f64MinEmphasizeFactor;
            double m_f64MaxEmphasizeFactor;

            bool m_bGaussianBlur;
            double m_f64GaussianBlurActivationRate;
            int64_t m_i64MinGaussianBlurKernelSize;
            int64_t m_i64MaxGaussianBlurKernelSize;

            bool m_bGaussianNoise;
            double m_f64GaussianNoiseActivationRate;
            double m_f64MinMean;
            double m_f64MaxMean;
            double m_f64MinStdev;
            double m_f64MaxStdev;

            bool m_bAlphaBlendMask;
            double m_f64AlphaBlendMaskActivationRate;
            int64_t m_i64MinAlphaBlendMaskCount;
            int64_t m_i64MaxAlphaBlendMaskCount;
            double m_f64MinAlphaBlendMaskRatioX;
            double m_f64MaxAlphaBlendMaskRatioX;
            double m_f64MinAlphaBlendMaskRatioY;
            double m_f64MaxAlphaBlendMaskRatioY;
            double m_f64MinAlphaBlendMaskValue;
            double m_f64MaxAlphaBlendMaskValue;
            double m_f64MinAlphaBlendMaskBlendRatio;
            double m_f64MaxAlphaBlendMaskBlendRatio;

            bool m_bPerspective;
            double m_f64PerspectiveActivationRate;
            double m_f64MinPerspectiveRatio;
            double m_f64MaxPerspectiveRatio;

            bool m_bQuarterRotation;
            double m_f64QuarterRotationActivationRate;
            bool m_bQuarterRotationAngle0;
            bool m_bQuarterRotationAngle90;
            bool m_bQuarterRotationAngle180;
            bool m_bQuarterRotationAngle270;

            bool m_bRotation;
            double m_f64RotationActivationRate;
            double m_f64MinAngle;
            double m_f64MaxAngle;
            bool m_bRectMode;
            bool m_bFitTensor;

            bool m_bScale;
            double m_f64ScaleActivationRate;
            double m_f64MinScaleRatioX;
            double m_f64MaxScaleRatioX;
            double m_f64MinScaleRatioY;
            double m_f64MaxScaleRatioY;
            bool m_bPreservingScaleRatio;

            bool m_bTranslation;
            double m_f64TranslationActivationRate;
            double m_f64MinTranslationRatioX;
            double m_f64MaxTranslationRatioX;
            double m_f64MinTranslationRatioY;
            double m_f64MaxTranslationRatioY;

            bool m_bCutout;
            double m_f64CutoutActivationRate;
            int64_t m_i64MinCutoutCount;
            int64_t m_i64MaxCutoutCount;
            double m_f64MinCutoutRatioX;
            double m_f64MaxCutoutRatioX;
            double m_f64MinCutoutRatioY;
            double m_f64MaxCutoutRatioY;
        };
 
    }
}
 
#pragma pack(pop)
#endif