ColorUtilities.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "ColorUtilities.h"
#include "Misc/DefaultValueHelper.h"
 
FLinearColor UColorUtilities::HexToLinearColor(const FString& HexString, bool& bSuccess)
{
 
    if (IsValidHexString(HexString))
    {
        bSuccess = true;
        /*
        Creates a color value from the given hexadecimal string.
        Supported formats are: RGB, RRGGBB, RRGGBBAA, RGB, #RRGGBB, #RRGGBBAA The corresponding color value.
        */
        FColor Color = FColor::FromHex(HexString);
        return Color.ReinterpretAsLinear();
    }
    else
    {
        //UE_LOG(LogTemp, Warning, TEXT("Invalid Hex String Format: %s"), *HexString);
        bSuccess = false;
        return FLinearColor::White;
    }
 
    // FString CleanHex = HexString.Replace(TEXT("#"), TEXT("")); // Remove #
 
    // if (CleanHex.Len() != 6 && CleanHex.Len() != 8)
    //{
    //  UE_LOG(LogTemp, Warning, TEXT("Invalid Hex Color Length: %s"), *HexString);
    //  return FLinearColor::White;
    // }
 
    // int32 R, G, B, A = 255; // Default alpha to 255
 
    // FDefaultValueHelper::ParseInt(CleanHex.Mid(0, 2), R, 16);
    // FDefaultValueHelper::ParseInt(CleanHex.Mid(2, 2), G, 16);
    // FDefaultValueHelper::ParseInt(CleanHex.Mid(4, 2), B, 16);
 
    // if (CleanHex.Len() == 8)
    //{
    //  FDefaultValueHelper::ParseInt(CleanHex.Mid(6, 2), A, 16);
    // }
 
    // return FLinearColor(R / 255.0f, G / 255.0f, B / 255.0f, A / 255.0f);
}
 
FLinearColor UColorUtilities::RGBStringToLinearColor(const FString& ColorString, bool& bSuccess)
{
    if (IsValidRGBString(ColorString))
    {
        bSuccess = true;
        TArray<FString> Components;
        ColorString.ParseIntoArray(Components, TEXT(","), true);
 
        int32 R = 0, G = 0, B = 0, A = 255; // Default alpha to 255 (fully opaque)
 
        // Parse integer values from the string components
        FDefaultValueHelper::ParseInt(Components[0], R);
        FDefaultValueHelper::ParseInt(Components[1], G);
        FDefaultValueHelper::ParseInt(Components[2], B);
 
        if (Components.Num() == 4) // If alpha is provided
        {
            FDefaultValueHelper::ParseInt(Components[3], A);
        }
 
        // Convert to linear color
        return FLinearColor(R / 255.0f, G / 255.0f, B / 255.0f, A / 255.0f);
    }
 
    // Invalid string format
    bSuccess = false;
    
    //UE_LOG(LogTemp, Warning, TEXT("Invalid Color String Format: %s"), *ColorString);
 
    return FLinearColor::White;
}
 
FString UColorUtilities::LinearColorToHex(const FLinearColor& Color, bool bIncludeAlpha, bool bAddPrefix)
{
    FColor ConvertedColor = Color.QuantizeRound();  // Converts FLinearColor to FColor
    FString HexString = ConvertedColor.ToHex();     // Returns RRGGBBAA format
 
    if (!bIncludeAlpha)
    {
        HexString = HexString.Left(6);          // Trim the last two characters (AA)
    }
 
    if (bAddPrefix)
    {
        HexString = FString("#") + HexString;
    }
 
    return HexString;
 
    // int32 R = FMath::RoundToInt(Color.R * 255);
    // int32 G = FMath::RoundToInt(Color.G * 255);
    // int32 B = FMath::RoundToInt(Color.B * 255);
    // int32 A = FMath::RoundToInt(Color.A * 255);
 
    // FString HexString = FString::Printf(TEXT("#%02X%02X%02X"), R, G, B);
 
    // if (bIncludeAlpha)
    //{
    //  HexString += FString::Printf(TEXT("%02X"), A);
    // }
 
    // return HexString;
}
 
FString UColorUtilities::LinearColorToRGBString(const FLinearColor& Color, bool bIncludeAlpha)
{
    int32 R = FMath::RoundToInt(Color.R * 255);
    int32 G = FMath::RoundToInt(Color.G * 255);
    int32 B = FMath::RoundToInt(Color.B * 255);
    int32 A = FMath::RoundToInt(Color.A * 255);
 
    if (bIncludeAlpha)
    {
        return FString::Printf(TEXT("%d,%d,%d,%d"), R, G, B, A);
    }
    else
    {
        return FString::Printf(TEXT("%d,%d,%d"), R, G, B);
    }
}
 
bool UColorUtilities::IsValidRGBString(const FString& ColorString)
{
    FString TrimmedString = ColorString.TrimStartAndEnd(); // Remove whitespace
    TArray<FString> Components;
    TrimmedString.ParseIntoArray(Components, TEXT(","), true);
 
    // RGB(A) must have 3 or 4 integer values
    if (Components.Num() < 3 || Components.Num() > 4)
    {
        return false;
    }
 
    for (const FString& Component : Components)
    {
        int32 Value;
        if (!FDefaultValueHelper::ParseInt(Component, Value) || Value < 0 || Value > 255)
        {
            return false; // Must be an integer between 0-255
        }
    }
 
    return true; // Valid RGB or RGBA format
}
 
bool UColorUtilities::IsValidHexString(const FString& ColorString)
{
    FString TrimmedString = ColorString.TrimStartAndEnd().Replace(TEXT("#"), TEXT("")); // Remove '#' if present
 
    // Must be exactly 6 (RRGGBB) or 8 (RRGGBBAA) characters long, shorthand (RGB) not supported
    if (TrimmedString.Len() != 6 && TrimmedString.Len() != 8)
    {
        return false;
    }
 
    // Ensure all characters are valid hex digits (0-9, A-F, a-f)
    for (TCHAR Char : TrimmedString)
    {
        if (!FChar::IsHexDigit(Char))
        {
            return false;
        }
    }
 
    return true; // Valid hex format
}
 
FLinearColor UColorUtilities::AutoDetectColorStringToLinearColor(const FString& ColorString, bool& bSuccess)
{
    FString TrimmedString = ColorString.TrimStartAndEnd(); // Remove leading/trailing spaces
    FLinearColor ConvertedColor;
 
    // First try to convert string to linear color assuming it's rgb
    ConvertedColor = RGBStringToLinearColor(TrimmedString, bSuccess);
 
    // If that fails, assume it's hex
    if (!bSuccess)
    {
        ConvertedColor = HexToLinearColor(TrimmedString, bSuccess);
    }
 
    // return converted color (and bSuccess). ConvertedColor set to FLinearColor::White if conversion failed in previous steps
    return ConvertedColor;
}