ATreeHeightsFromImage Class Reference

#include <TreeHeightsFromImage.h>

Inheritance diagram for ATreeHeightsFromImage:

Collaboration diagram for ATreeHeightsFromImage:

Public Member Functions
	ATreeHeightsFromImage ()

Public Attributes
UTexture2D *	treeMapImage

Protected Member Functions
virtual void	BeginPlay () override
float	EuclideanDistance (const FColor &Color1, const FColor &Color2)
FColor	FindClosestColor (const FColor &TargetColor, const TMap< int32, FColor > &ColorMap)

Protected Attributes
const TMap< int, FColor >	colorHeight

Detailed Description

Definition at line 15 of file TreeHeightsFromImage.h.

Constructor & Destructor Documentation

ATreeHeightsFromImage()

ATreeHeightsFromImage::ATreeHeightsFromImage

(

)

Definition at line 8 of file TreeHeightsFromImage.cpp.

{
    PrimaryActorTick.bCanEverTick = false;
}

Member Function Documentation

BeginPlay()

void ATreeHeightsFromImage::BeginPlay ( )

overrideprotectedvirtual

Definition at line 13 of file TreeHeightsFromImage.cpp.

{
    Super::BeginPlay();
 
#if WITH_EDITOR
    if (treeMapImage)
    {
        // Lock the texture to allow access to data
        FTexture2DMipMap& Mip = treeMapImage->GetPlatformData()->Mips[0];
        void* Data = Mip.BulkData.Lock(LOCK_READ_ONLY);
 
        if (Data)
        {
            int32 Width = treeMapImage->GetSizeX();
            int32 Height = treeMapImage->GetSizeY();
 
            if (Width <= 0 || Height <= 0)
                return;
 
            UE_LOG(LogTemp, Warning, TEXT("Image width: %i, Height: %i"), Width, Height);
 
            uint8* Pixels = static_cast<uint8*>(Data);
            for (int32 y = 0; y < Height; y++)
            {
                for (int32 x = 0; x < Width; x++)
                {
                    int32 Index = (y * Width + x) * 4; // 4 bytes per pixel (RGBA)
                    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);
 
                    if (x == 446 && y == 353)
                    {
                        UE_LOG(LogTemp, Warning, TEXT("Coordinates RGB = %i, %i, %i"), B, G, R);
                        FColor ClosestColor = FindClosestColor(pixelColor, colorHeight);
                        UE_LOG(LogTemp, Warning, TEXT("Closest color: R=%d, G=%d, B=%d"), ClosestColor.R, ClosestColor.G, ClosestColor.B);
 
                        for (const auto& Pair : colorHeight)
                        {
                            if (Pair.Value == ClosestColor)
                                UE_LOG(LogTemp, Warning, TEXT("This should be a %im size tree"), Pair.Key);
                        }
 
                    }
 
                    if (x == Width / 2 && y == Height / 2)
                    {
                        UE_LOG(LogTemp, Warning, TEXT("Coordinates middlepoint Width: %i, Height: %i"), x, y);
                        //UE_LOG(LogTemp, Warning, TEXT("ARGB: %i,%i,%i,%i"), A,R,G,B);
                    }
                }
            }
 
            // Unlock the texture
            Mip.BulkData.Unlock();
        }
    }
#endif
}

References colorHeight, FindClosestColor(), and treeMapImage.

EuclideanDistance()

float ATreeHeightsFromImage::EuclideanDistance ( const FColor &  Color1, const FColor &  Color2  )

protected

Definition at line 76 of file TreeHeightsFromImage.cpp.

{
    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));
}

Referenced by FindClosestColor().

FindClosestColor()

FColor ATreeHeightsFromImage::FindClosestColor ( const FColor &  TargetColor, const TMap< int32, FColor > &  ColorMap  )

protected

Definition at line 87 of file TreeHeightsFromImage.cpp.

{
    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;
}

References EuclideanDistance().

Referenced by BeginPlay().

Member Data Documentation

colorHeight

const TMap<int, FColor> ATreeHeightsFromImage::colorHeight

protected

Initial value:

= {
        {0, FColor(48, 18, 59)},
        {1, FColor(59, 48, 129)},
        {2, FColor(67, 77, 183)},
        {3, FColor(70, 104, 222)},
        {4, FColor(70, 130, 247)},
        {5, FColor(61, 156, 252)},
        {6, FColor(44, 182, 239)},
        {7, FColor(30, 205, 216)},
        {8, FColor(26, 223, 190)},
        {9, FColor(42, 237, 163)},
        {10, FColor(73, 247, 130)},
        {11, FColor(111, 253, 97)},
        {12, FColor(147, 253, 71)},
        {13, FColor(177, 248, 56)},
        {14, FColor(203, 236, 53)},
        {15, FColor(226, 219, 56)},
        {16, FColor(243, 199, 57)},
        {17, FColor(252, 176, 53)},
        {18, FColor(253, 148, 43)},
        {19, FColor(249, 118, 30)},
        {20, FColor(239, 89, 17)},
        {21, FColor(224, 65, 9)},
        {22, FColor(205, 45, 5)},
        {23, FColor(181, 28, 2)},
        {24, FColor(153, 14, 1)},
        {25, FColor(122, 4, 3)}
    }

Definition at line 31 of file TreeHeightsFromImage.h.

Referenced by BeginPlay().

treeMapImage

UTexture2D* ATreeHeightsFromImage::treeMapImage

Definition at line 64 of file TreeHeightsFromImage.h.

Referenced by BeginPlay().

---

The documentation for this class was generated from the following files:

• Unreal/Agrarsense/Source/Agrarsense/Prop/TreeHeightsFromImage.h
• Unreal/Agrarsense/Source/Agrarsense/Prop/TreeHeightsFromImage.cpp