ImageWriteTask.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ContainersFwd.h"
#include "Containers/UnrealString.h"
#include "HAL/Platform.h"
#include "IImageWrapper.h"
#include "ImagePixelData.h"
#include "Math/Color.h"
#include "Math/Float16.h"
#include "Math/Float16Color.h"
#include "Math/IntPoint.h"
#include "Misc/AssertionMacros.h"
#include "Misc/CoreDefines.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
 
template<typename> struct TImageDataTraits;
 
typedef TUniqueFunction<void(FImagePixelData*)> FPixelPreProcessor;
 
class IImageWriteTaskBase
{
public:
 
    virtual ~IImageWriteTaskBase() {}
 
    virtual bool RunTask() = 0;
 
    virtual void OnAbandoned() = 0;
};
 
class FImageWriteTask
    : public IImageWriteTaskBase
{
public:
 
    FString Filename;
 
    EImageFormat Format;
 
    int32 CompressionQuality;
 
    bool bOverwriteFile;
 
    TFunction<void(bool)> OnCompleted;
 
    TUniquePtr<FImagePixelData> PixelData;
 
    TArray<FPixelPreProcessor> PixelPreProcessors;
 
    FImageWriteTask()
        : Format(EImageFormat::BMP)
        , CompressionQuality((int32)EImageCompressionQuality::Default)
        , bOverwriteFile(true)
    {}
 
public:
 
    IMAGEWRITEQUEUE_API virtual bool RunTask() override final;
    IMAGEWRITEQUEUE_API virtual void OnAbandoned() override final;
 
    IMAGEWRITEQUEUE_API void AddPreProcessorToSetAlphaOpaque();
 
private:
 
    bool WriteToDisk();
 
    bool EnsureWritableFile();
 
    bool InitializeWrapper(IImageWrapper* InWrapper, EImageFormat WrapperFormat);
 
 
    void PreProcess();
};
 
 
template<typename PixelType> struct TAsyncAlphaWrite;
 
template<>
struct TAsyncAlphaWrite<FColor> // prefer AddPreProcessorToSetAlphaOpaque
{
    uint8 Alpha;
    TAsyncAlphaWrite(uint8 InAlpha) : Alpha(InAlpha) {}
 
    void operator()(FImagePixelData* PixelData)
    {
        check(PixelData->GetType() == EImagePixelType::Color);
 
        TImagePixelData<FColor>* ColorData = static_cast<TImagePixelData<FColor>*>(PixelData);
        for (FColor& Pixel : static_cast<TImagePixelData<FColor>*>(PixelData)->Pixels)
        {
            Pixel.A = Alpha;
        }
    }
};
 
template<>
struct TAsyncAlphaWrite<FFloat16Color> // prefer AddPreProcessorToSetAlphaOpaque
{
    FFloat16 Alpha;
    TAsyncAlphaWrite(float InAlpha) : Alpha(InAlpha) {}
 
    void operator()(FImagePixelData* PixelData)
    {
        check(PixelData->GetType() == EImagePixelType::Float16);
 
        TImagePixelData<FFloat16Color>* Float16ColorData = static_cast<TImagePixelData<FFloat16Color>*>(PixelData);
        for (FFloat16Color& Pixel : Float16ColorData->Pixels)
        {
            Pixel.A = Alpha;
        }
    }
};
 
template<>
struct TAsyncAlphaWrite<FLinearColor> // prefer AddPreProcessorToSetAlphaOpaque
{
    float Alpha;
    TAsyncAlphaWrite(float InAlpha) : Alpha(InAlpha) {}
 
    void operator()(FImagePixelData* PixelData)
    {
        check(PixelData->GetType() == EImagePixelType::Float32);
 
        TImagePixelData<FLinearColor>* LinearColorData = static_cast<TImagePixelData<FLinearColor>*>(PixelData);
        for (FLinearColor& Pixel : LinearColorData->Pixels)
        {
            Pixel.A = Alpha;
        }
    }
};
 
template<typename PixelType> struct TAsyncAlphaInvert;
 
template<>
struct TAsyncAlphaInvert<FColor>
{
    void operator()(FImagePixelData* PixelData)
    {
        check(PixelData->GetType() == EImagePixelType::Color);
 
        TImagePixelData<FColor>* ColorData = static_cast<TImagePixelData<FColor>*>(PixelData);
        for (FColor& Pixel : static_cast<TImagePixelData<FColor>*>(PixelData)->Pixels)
        {
            Pixel.A = 255 - Pixel.A;
        }
    }
};
 
template<>
struct TAsyncAlphaInvert<FFloat16Color>
{
    void operator()(FImagePixelData* PixelData)
    {
        check(PixelData->GetType() == EImagePixelType::Float16);
 
        TImagePixelData<FFloat16Color>* Float16ColorData = static_cast<TImagePixelData<FFloat16Color>*>(PixelData);
        for (FFloat16Color& Pixel : Float16ColorData->Pixels)
        {
            Pixel.A = FFloat16(1.f - Pixel.A.GetFloat());
        }
    }
};
 
template<>
struct TAsyncAlphaInvert<FLinearColor>
{
    void operator()(FImagePixelData* PixelData)
    {
        check(PixelData->GetType() == EImagePixelType::Float32);
 
        TImagePixelData<FLinearColor>* LinearColorData = static_cast<TImagePixelData<FLinearColor>*>(PixelData);
        for (FLinearColor& Pixel : LinearColorData->Pixels)
        {
            Pixel.A = 1.f - Pixel.A;
        }
    }
};