Added texture Quantization and a window to test it

Runtime/ImageQuantizer.cs

@@ -0,0 +1,137 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ImageQuantizer
+{
+    /// <summary>
+    /// Quantizes a texture and outputs a 3D pixel array.
+    /// </summary>
+    /// <param name="image">The input texture.</param>
+    /// <param name="maxColors">The maximum number of colors in the quantized image.</param>
+    /// <param name="maxIterations">The maximum number of iterations for the k-means algorithm.</param>
+    /// <returns>A tuple containing a 3D pixel array and the color lookup table.</returns>
+    public static (float[,,], Vector3[,]) Quantize(Texture2D image, int maxColors, int maxIterations = 10)
+    {
+        int width = image.width;
+        int height = image.height;
+
+        List<Vector3> centroids = InitializeCentroids(image, maxColors);
+
+        Color[] pixels = image.GetPixels();
+        Vector3[] pixelColors = new Vector3[pixels.Length];
+        for (int i = 0; i < pixels.Length; i++)
+        {
+            pixelColors[i] = new Vector3(pixels[i].r, pixels[i].g, pixels[i].b);
+        }
+
+        // Storage for pixel-to-centroid assignments
+        int[] assignments = new int[pixelColors.Length];
+
+        for (int iteration = 0; iteration < maxIterations; iteration++)
+        {
+            bool centroidsChanged = false;
+
+            // Step 1: Assign each pixel to the closest centroid
+            for (int i = 0; i < pixelColors.Length; i++)
+            {
+                int closestCentroid = GetClosestCentroid(pixelColors[i], centroids);
+                if (assignments[i] != closestCentroid)
+                {
+                    assignments[i] = closestCentroid;
+                    centroidsChanged = true;
+                }
+            }
+
+            // Step 2: Recalculate centroids
+            Vector3[] newCentroids = new Vector3[centroids.Count];
+            int[] centroidCounts = new int[centroids.Count];
+
+            for (int i = 0; i < assignments.Length; i++)
+            {
+                int centroidIndex = assignments[i];
+                newCentroids[centroidIndex] += pixelColors[i];
+                centroidCounts[centroidIndex]++;
+            }
+
+            for (int i = 0; i < centroids.Count; i++)
+            {
+                if (centroidCounts[i] > 0)
+                {
+                    newCentroids[i] /= centroidCounts[i];
+                }
+                else
+                {
+                    newCentroids[i] = RandomizeCentroid(image);
+                }
+            }
+
+            if (!centroidsChanged) break;
+
+            centroids = new List<Vector3>(newCentroids);
+        }
+
+        float[,,] pixelArray = new float[width, height, 3];
+        for (int i = 0; i < pixelColors.Length; i++)
+        {
+            int x = i % width;
+            int y = i / width;
+
+            Vector3 centroidColor = centroids[assignments[i]];
+            pixelArray[x, y, 0] = centroidColor.x; // Red
+            pixelArray[x, y, 1] = centroidColor.y; // Green
+            pixelArray[x, y, 2] = centroidColor.z; // Blue
+        }
+
+        Vector3[,] clut = new Vector3[maxColors, 1];
+        for (int i = 0; i < centroids.Count; i++)
+        {
+            clut[i, 0] = centroids[i];
+        }
+
+        return (pixelArray, clut);
+    }
+
+    private static List<Vector3> InitializeCentroids(Texture2D image, int maxColors)
+    {
+        List<Vector3> centroids = new List<Vector3>();
+        Color[] pixels = image.GetPixels();
+        HashSet<Vector3> uniqueColors = new HashSet<Vector3>();
+
+        foreach (Color pixel in pixels)
+        {
+            Vector3 color = new Vector3(pixel.r, pixel.g, pixel.b);
+            if (!uniqueColors.Contains(color))
+            {
+                uniqueColors.Add(color);
+                centroids.Add(color);
+                if (centroids.Count >= maxColors) break;
+            }
+        }
+
+        return centroids;
+    }
+
+    private static Vector3 RandomizeCentroid(Texture2D image)
+    {
+        Color randomPixel = image.GetPixel(Random.Range(0, image.width), Random.Range(0, image.height));
+        return new Vector3(randomPixel.r, randomPixel.g, randomPixel.b);
+    }
+
+    private static int GetClosestCentroid(Vector3 color, List<Vector3> centroids)
+    {
+        int closestCentroid = 0;
+        float minDistanceSq = float.MaxValue;
+
+        for (int i = 0; i < centroids.Count; i++)
+        {
+            float distanceSq = (color - centroids[i]).sqrMagnitude;
+            if (distanceSq < minDistanceSq)
+            {
+                minDistanceSq = distanceSq;
+                closestCentroid = i;
+            }
+        }
+
+        return closestCentroid;
+    }
+}