TreeHeightsFromImageComponent.cpp

Go to the documentation of this file.

// Copyright (c) 2024 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 "TreeHeightsFromImageComponent.h"
#include <string.h>
 
UTreeHeightsFromImageComponent::UTreeHeightsFromImageComponent()
{
    PrimaryComponentTick.bCanEverTick = false;
}
 
void UTreeHeightsFromImageComponent::BeginPlay()
{
    Super::BeginPlay();
}
 
void UTreeHeightsFromImageComponent::CacheTexture()
{
#if WITH_EDITOR
    FString TexturePath = TEXT("/Game/Agrarsense/Maps/Vindeln/CHM_Vindeln.CHM_Vindeln");
    treeMapImage = Cast<UTexture2D>(StaticLoadObject(UTexture2D::StaticClass(), nullptr, *TexturePath));
    if (treeMapImage)
    {
        FTexture2DMipMap& Mip = treeMapImage->GetPlatformData()->Mips[0];
        void* Data = Mip.BulkData.Lock(LOCK_READ_ONLY);
        int32 Size = Mip.BulkData.GetBulkDataSize();
        Pixels.Empty();
        Pixels.AddUninitialized(Size);
 
        std::memcpy(Pixels.GetData(), Data, Size);
 
        Mip.BulkData.Unlock();
 
        UE_LOG(LogTemp, Warning, TEXT("Tree image cached.."));
        UE_LOG(LogTemp, Warning, TEXT("Pixels data len %i"), Pixels.Num());
 
        Width = treeMapImage->GetSizeX();
        Height = treeMapImage->GetSizeY();
 
        UE_LOG(LogTemp, Warning, TEXT("Source image resolution: %i x %i"), Width, Height);
    }
#endif
}
 
float UTreeHeightsFromImageComponent::EuclideanDistance(const FColor& Color1, const FColor& Color2)
{
    float R1 = Color1.R;
    float G1 = Color1.G;
    float B1 = Color1.B;
    float R2 = Color2.R;
    float G2 = Color2.G;
    float B2 = Color2.B;
    return FMath::Sqrt(FMath::Square(R2 - R1) + FMath::Square(G2 - G1) + FMath::Square(B2 - B1));
}
 
FColor UTreeHeightsFromImageComponent::FindClosestColor(const FColor& TargetColor, const TMap<int32, FColor>& ColorMap)
{
    float MinDistance = FLT_MAX;
    FColor ClosestColor;
 
    for (const auto& Pair : ColorMap)
    {
        float Distance = EuclideanDistance(TargetColor, Pair.Value);
        if (Distance < MinDistance)
        {
            MinDistance = Distance;
            ClosestColor = Pair.Value;
        }
    }
 
    return ClosestColor;
}
 
int UTreeHeightsFromImageComponent::GetColorFromPixel(FVector point)
{
    //if (!treeMapImage)
    //    return 0;// FColor::Black;
 
 
    if (Pixels.IsEmpty())
    {
        UE_LOG(LogTemp, Warning, TEXT("Returning from Pixels are empty!"));
        return 0;
    }
 
 
 
    //UE_LOG(LogTemp, Warning, TEXT("Coordinate: %f"), point);
 
    point.X /= 122.9033;
    point.Y /= 122.9033;
 
    if (point.X <= 0 || point.Y <= 0)
    {
        UE_LOG(LogTemp, Warning, TEXT("Returning from point less than 0"));
        return 0;// FColor::Black;
    }
 
    // Lock the texture to allow access to its data
    //FTexture2DMipMap& Mip = treeMapImage->GetPlatformData()->Mips[0];
 
    //if (Mip.BulkData.IsLocked())
    //    return;// FColor::Black;
 
    //if (Mip.BulkData.IsLocked())
    //    Mip.BulkData.Unlock();
 
    //void* Data = Mip.BulkData.Lock(LOCK_READ_ONLY);
 
    //if (!Data)
    //{
    //    Mip.BulkData.Unlock();
    //    return FColor::Black;
    //}
 
 
    // Get image resolution
    /*Width = treeMapImage->GetSizeX();
    Height = treeMapImage->GetSizeY();*/
 
    if (point.X > Width || point.Y > Height)
    {
        //Mip.BulkData.Unlock();
        UE_LOG(LogTemp, Warning, TEXT("Returning from point over the resolution"));
        return 0;
    }
 
    // If width and height not good, return black
    if (Width <= 0 || Height <= 0)
    {
        //if (Mip.BulkData.IsLocked())
        //Mip.BulkData.Unlock();
        UE_LOG(LogTemp, Warning, TEXT("Returning from width <= 0"));
        return 0;// FColor::Black;
    }
 
 
    //uint8* Pixels = static_cast<uint8*>(Data);
 
    int32 Index = ((int)point.Y * Width + (int)point.X) * 4; // 4 bytes per pixel (RGBA)
 
    if (Index + 3 <= Pixels.Num())
    {
        uint8 R = Pixels[Index];
        uint8 G = Pixels[Index + 1];
        uint8 B = Pixels[Index + 2];
        //uint8 A = Pixels[Index + 3];
 
        FColor pixelColor = FColor(B, G, R);
 
        FColor closestColor = FindClosestColor(pixelColor, colorHeight);
 
        for (const auto& Pair : colorHeight)
        {
            if (Pair.Value == closestColor)
            {
                UE_LOG(LogTemp, Warning, TEXT("This tree is : %i m"), Pair.Key);
                return Pair.Key;
            }
        }
    }
    else {
        UE_LOG(LogTemp, Warning, TEXT("Index out of range"));
    }
 
 
 
    // Unlock the texture
    //Mip.BulkData.Unlock();
 
    //return pixelColor;
    return 0;
}
 
#if WITH_EDITOR
void UTreeHeightsFromImageComponent::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
{
    Super::PostEditChangeProperty(PropertyChangedEvent);
 
    // Check if the custom button trigger has been toggled
    if (PropertyChangedEvent.Property != nullptr && PropertyChangedEvent.Property->GetName() == "GenerateTrigger")
    {
        if (GenerateTrigger)
        {
            CacheTexture();
            GenerateTrigger = false;
        }
    }
}
#endif