Rearrange a picture into another (Unity C#) (Two different images)

using System.ComponentModel;
using UnityEngine;
using System.Collections;
using UnityEngine.XR;

public class Main : MonoBehaviour
{
    //Based on this article: https://estebanhufstedler.com/2020/06/08/rearrange-a-picture-into-another/
    public Texture2D[] sourceImages;
    public Texture2D[] targetImages;

    public int segmentSize;

    public float imageScale;

    public bool rotateTiles;

    public string executionTime;

    Texture2D[,,] sourceTiles;
    Texture2D[,] targetTiles;
    Texture2D[,] modifiedTiles;

    Color[,,][] sourceTilePixels;
    Color[,][] targetTilePixels;

    int ySegments;
    int xSegments;

    void Start()
    {
        float startTime = Time.realtimeSinceStartup;

        for (int i = 0; i < 2; i++)
        {
            if (sourceImages[i].width != targetImages[i].width || sourceImages[i].height != targetImages[i].height)
            {
                Debug.LogError("Images must have the same dimensions!");
                return;
            }
            ySegments = sourceImages[i].height / segmentSize;
            xSegments = sourceImages[i].width / segmentSize;

            sourceTiles = new Texture2D[xSegments, ySegments, 4];
            targetTiles = new Texture2D[xSegments, ySegments];
            modifiedTiles = new Texture2D[xSegments, ySegments];

            sourceTilePixels = new Color[xSegments, ySegments, 4][];
            targetTilePixels = new Color[xSegments, ySegments][];

            for (int y = 0; y < ySegments; y++)
            {
                for (int x = 0; x < xSegments; x++)
                {
                    CreateTile(x, y, i);
                }
            }

            for (int y = 0; y < ySegments; y++)
            {
                for (int x = 0; x < xSegments; x++)
                {
                    MatchTileToTarget(x, y);
                }
            }

            GameObject parent = new GameObject();
            parent.name = "Image " + (i+1);

            for (int y = 0; y < ySegments; y++)
            {
                for (int x = 0; x < xSegments; x++)
                {
                    GameObject tile = GameObject.CreatePrimitive(PrimitiveType.Quad);

                    tile.name = "Tile";
                    tile.transform.position = new Vector3(x * xSegments, y * xSegments, 0);
                    tile.transform.localScale = new Vector3(xSegments, xSegments);
                    tile.transform.parent = parent.transform;

                    tile.GetComponent<MeshRenderer>().material = new Material(Shader.Find("Unlit/Texture"));
                    tile.GetComponent<MeshRenderer>().material.mainTexture = modifiedTiles[x, y];
                }
            }

            parent.transform.position = new Vector3(i == 0 ? -0.1f : -27.8f, 5.5f, 0);
            parent.transform.localScale = new Vector3(0.045f, 0.045f, 0);
        }

        executionTime = ((Time.realtimeSinceStartup - startTime) * 1000f) + "ms";
    }

    void CreateTile(int x, int y, int imageIndex)
    {
        Color[] sourceColors = sourceImages[imageIndex].GetPixels(x * segmentSize, y * segmentSize, segmentSize, segmentSize);
        sourceTiles[x, y, 0] = new Texture2D(segmentSize, segmentSize);
        sourceTiles[x, y, 0].SetPixels(sourceColors);
        sourceTiles[x, y, 0].Apply();

        sourceTilePixels[x, y, 0] = sourceTiles[x, y, 0].GetPixels();

        //Create rotated version of tiles
        for (int i = 1; i < 4; i++)
        {
            sourceTiles[x, y, i] = RotateTexture(sourceTiles[x, y, i - 1], true);
            sourceTiles[x, y, i].Apply();
            sourceTilePixels[x, y, i] = sourceTiles[x, y, i].GetPixels();
        }

        targetTiles[x, y] = new Texture2D(segmentSize, segmentSize);

        Color[] targetColors = targetImages[imageIndex].GetPixels(x * segmentSize, y * segmentSize, segmentSize, segmentSize);

        targetTiles[x, y].SetPixels(targetColors);
        targetTiles[x, y].Apply();
        targetTilePixels[x, y] = targetTiles[x, y].GetPixels();
    }

    void MatchTileToTarget(int xCoord, int yCoord)
    {
        int xOptimalCoord = 0;
        int yOptimalCoord = 0;
        int optimalRotation = 0;

        float minCost = float.MaxValue;

        for (int y = 0; y < ySegments; y++)
        {
            for (int x = 0; x < xSegments; x++)
            {
                if (modifiedTiles[x, y] == null)
                {
                    for (int i = 0; i < 4; i++)
                    {
                        float cost = CalculateCost(xCoord, yCoord, i, x, y);
                        if (cost < minCost)
                        {
                            minCost = cost;
                            xOptimalCoord = x;
                            yOptimalCoord = y;
                            optimalRotation = i;
                        }
                    }

                }
            }
        }

        modifiedTiles[xOptimalCoord, yOptimalCoord] = sourceTiles[xCoord, yCoord, rotateTiles ? optimalRotation : 0];
    }

    float CalculateCost(int x1, int y1, int rot, int x2, int y2)
    {
        Color[] pixels1 = sourceTilePixels[x1, y1, rot];
        Color[] pixels2 = targetTilePixels[x2, y2];

        float totalDiff = 0;

        for (int i = 0; i < pixels1.Length; i++)
        {
            float r1 = pixels1[i].r;
            float g1 = pixels1[i].g;
            float b1 = pixels1[i].b;

            float r2 = pixels2[i].r;
            float g2 = pixels2[i].g;
            float b2 = pixels2[i].b;

            float redDiff = (r1 - r2) * (r1 - r2);
            float greenDiff = (g1 - g2) * (g1 - g2);
            float blueDiff = (b1 - b2) * (b1 - b2);

            totalDiff += redDiff + greenDiff + blueDiff;
        }
        return totalDiff;
    }



    Texture2D RotateTexture(Texture2D originalTexture, bool clockwise)
    {
        Color32[] original = originalTexture.GetPixels32();
        Color32[] rotated = new Color32[original.Length];
        int w = originalTexture.width;
        int h = originalTexture.height;

        int iRotated, iOriginal;

        for (int j = 0; j < h; ++j)
        {
            for (int i = 0; i < w; ++i)
            {
                iRotated = (i + 1) * h - j - 1;
                iOriginal = clockwise ? original.Length - 1 - (j * w + i) : j * w + i;
                rotated[iRotated] = original[iOriginal];
            }
        }

        Texture2D rotatedTexture = new Texture2D(h, w);
        rotatedTexture.SetPixels32(rotated);
        rotatedTexture.Apply();
        return rotatedTexture;
    }
}