| | | 1 | | using System; |
| | | 2 | | using System.Collections; |
| | | 3 | | using System.Collections.Generic; |
| | | 4 | | using UnityEngine; |
| | | 5 | | |
| | | 6 | | // The k-means clusterer class performs k-means clustering. |
| | | 7 | | public class KMeansClusterer : IClusterer { |
| | | 8 | | public const float Epsilon = 1e-3f; |
| | | 9 | | |
| | | 10 | | // Number of clusters. |
| | | 11 | | private int _k = 0; |
| | | 12 | | |
| | | 13 | | // Maximum number of iterations. |
| | | 14 | | private int _maxIterations = 20; |
| | | 15 | | |
| | | 16 | | public KMeansClusterer(List<GameObject> objects, int k, int maxIterations = 20) : base(objects) { |
| | | 17 | | _k = k; |
| | | 18 | | _maxIterations = maxIterations; |
| | | 19 | | } |
| | | 20 | | public KMeansClusterer(List<Agent> agents, int k, int maxIterations = 20) : base(agents) { |
| | | 21 | | _k = k; |
| | | 22 | | _maxIterations = maxIterations; |
| | | 23 | | } |
| | | 24 | | |
| | | 25 | | // Cluster the game objects. |
| | | 26 | | public override void Cluster() { |
| | | 27 | | // Initialize the clusters with centroids located at random game objects. |
| | | 28 | | // Perform Fisher-Yates shuffling to find k random game objects. |
| | | 29 | | System.Random random = new System.Random(); |
| | | 30 | | for (int i = _objects.Count - 1; i >= _objects.Count - _k; --i) { |
| | | 31 | | int j = random.Next(i + 1); |
| | | 32 | | (_objects[i], _objects[j]) = (_objects[j], _objects[i]); |
| | | 33 | | } |
| | | 34 | | for (int i = _objects.Count - 1; i >= _objects.Count - _k; --i) { |
| | | 35 | | _clusters.Add(new Cluster(_objects[i])); |
| | | 36 | | } |
| | | 37 | | |
| | | 38 | | bool converged = false; |
| | | 39 | | int iteration = 0; |
| | | 40 | | while (!converged && iteration < _maxIterations) { |
| | | 41 | | AssignObjectsToCluster(); |
| | | 42 | | |
| | | 43 | | // Calculate the new clusters as the mean of all assigned game objects. |
| | | 44 | | converged = true; |
| | | 45 | | for (int clusterIndex = 0; clusterIndex < _clusters.Count; ++clusterIndex) { |
| | | 46 | | Cluster newCluster; |
| | | 47 | | if (_clusters[clusterIndex].IsEmpty()) { |
| | | 48 | | int objectIndex = random.Next(_objects.Count); |
| | | 49 | | newCluster = new Cluster(_objects[objectIndex]); |
| | | 50 | | } else { |
| | | 51 | | newCluster = new Cluster(_clusters[clusterIndex].Centroid()); |
| | | 52 | | } |
| | | 53 | | |
| | | 54 | | // Check whether the algorithm has converged by checking whether the cluster has moved. |
| | | 55 | | if (Vector3.Distance(newCluster.Coordinates, _clusters[clusterIndex].Coordinates) > |
| | | 56 | | Epsilon) { |
| | | 57 | | converged = false; |
| | | 58 | | } |
| | | 59 | | |
| | | 60 | | _clusters[clusterIndex] = newCluster; |
| | | 61 | | } |
| | | 62 | | |
| | | 63 | | ++iteration; |
| | | 64 | | } |
| | | 65 | | |
| | | 66 | | AssignObjectsToCluster(); |
| | | 67 | | } |
| | | 68 | | |
| | | 69 | | private void AssignObjectsToCluster() { |
| | | 70 | | // Determine the closest centroid to each game object. |
| | | 71 | | foreach (var obj in _objects) { |
| | | 72 | | float minDistance = Mathf.Infinity; |
| | | 73 | | int minIndex = -1; |
| | | 74 | | for (int clusterIndex = 0; clusterIndex < _clusters.Count; ++clusterIndex) { |
| | | 75 | | float distance = |
| | | 76 | | Vector3.Distance(_clusters[clusterIndex].Coordinates, obj.transform.position); |
| | | 77 | | if (distance < minDistance) { |
| | | 78 | | minDistance = distance; |
| | | 79 | | minIndex = clusterIndex; |
| | | 80 | | } |
| | | 81 | | } |
| | | 82 | | _clusters[minIndex].AddObject(obj); |
| | | 83 | | } |
| | | 84 | | } |
| | | 85 | | } |
| | | 86 | | |
| | | 87 | | // The constrained k-means clusterer class performs k-means clustering under size and radius |
| | | 88 | | // constraints. |
| | | 89 | | public class ConstrainedKMeansClusterer : ISizeAndRadiusConstrainedClusterer { |
| | | 90 | | public ConstrainedKMeansClusterer(List<GameObject> objects, int maxSize, float maxRadius) |
| | 12 | 91 | | : base(objects, maxSize, maxRadius) {} |
| | | 92 | | |
| | | 93 | | // Cluster the game objects. |
| | 4 | 94 | | public override void Cluster() { |
| | 4 | 95 | | int numClusters = (int)Mathf.Ceil(_objects.Count / _maxSize); |
| | | 96 | | KMeansClusterer clusterer; |
| | 16 | 97 | | while (true) { |
| | 8 | 98 | | clusterer = new KMeansClusterer(_objects, numClusters); |
| | 8 | 99 | | clusterer.Cluster(); |
| | | 100 | | |
| | | 101 | | // Count the number of over-populated and over-sized clusters. |
| | 8 | 102 | | int numOverPopulatedClusters = 0; |
| | 8 | 103 | | int numOverSizedClusters = 0; |
| | 78 | 104 | | foreach (var cluster in clusterer.Clusters) { |
| | 18 | 105 | | if (cluster.Size() > _maxSize) { |
| | 0 | 106 | | ++numOverPopulatedClusters; |
| | 0 | 107 | | } |
| | 22 | 108 | | if (cluster.Radius() > _maxRadius) { |
| | 4 | 109 | | ++numOverSizedClusters; |
| | 4 | 110 | | } |
| | 18 | 111 | | } |
| | | 112 | | |
| | | 113 | | // If all clusters satisfy the size and radius constraints, the algorithm has converged. |
| | 12 | 114 | | if (numOverPopulatedClusters == 0 && numOverSizedClusters == 0) { |
| | 4 | 115 | | break; |
| | | 116 | | } |
| | | 117 | | |
| | 4 | 118 | | numClusters += |
| | | 119 | | (int)Mathf.Ceil(Mathf.Max(numOverPopulatedClusters, numOverSizedClusters) / 2.0f); |
| | 4 | 120 | | } |
| | 4 | 121 | | _clusters = new List<Cluster>(clusterer.Clusters); |
| | 4 | 122 | | } |
| | | 123 | | } |