Init

Author: markuszeller

.gitignore

@@ -0,0 +1,54 @@
+![java processing3](https://img.shields.io/badge/java-processing3-orange)
+![algorithm k-means](https://img.shields.io/badge/algorithm-k--means-blueviolet)
+![licence MIT](https://img.shields.io/badge/license-MIT-green)
+
+# K-Means
+
+This is is a graphical fun project visualizing the effect of the [k-means](https://en.wikipedia.org/wiki/K-means_clustering) clustering algorithm which is used in data science to analyse many data points into groups.
+
+## Example collage
+
+In the example below you see the colums with 100x100, 200x200, 400x400 and 800x800 datapoints. The rows are the groupsize of 1, 2, 4, 8, 16, 50, 100, 200 and 2000. The images were all rendered in 800x800.
+
+![collage](examples/kmeans_collage.png)
+
+## Example rendering
+
+groupSize 64 | groupSize 8
+- | -
+100x100 datapoints | 100x100 datapoints
+![render_example_1](examples/render_1.gif) | ![render_example_1](examples/render_2.gif)
+
+In this program you can configure some options to influence the graphics produced and to be auto-saved.
+
+## Configuration
+
+The code has at the beginning a configuration section. The options are described below and summarized in the code itself. Default values are included.
+
+- **renderSize**  
+To specify the render size set the resolution in the setup() method. For HD with 1280 x 720 call the size() method like below. *Unfortunately this can not be a variable like the others due to [Processing](https://processing.org/) limitation.*  
+    ```size(1280, 720);```  
+
+- **groupSize**  
+    How many groups to you want to have? Minium is 1, maximum is unlimed, but it makes no sense to take a very high number. These groups will be generated randomly.
+
+- **dataPointSize**  
+   How many points to you want? The more you have, the clearer the result will be. Think of it like a screen resolution and better give as a number like x * y (200 * 200). These data points will be generated randomly.
+
+- **paddingSize**  
+    This will keep a padding of pixels of painting the groups and data points.
+
+- **blurStrength**  
+    After every pass a blur filter is applied. Think of it as an antialiasing value. 2 would affect a 2x2 blurring. Can be 0 if you do not like it.
+
+- **finalBlurStrength**  
+    Same as blurStrength, but will be applied at the finish.
+
+- **rotateColors**  
+    The color palette is generated for each time. To get a more interesting image, you can enable rotating the color palette. This will run every pass, if enabled.
+
+- **saveImage**  
+    The images will be stored into the data directory, when this option is enabled. Filename format is `<timestamp>_gs<groupsize>_dp<datapoints>.png`. That makes it flexible to reuse configuration of the options you like.
+
+- **loopSize**  
+    Because of the random factors, every picture will be individual. The points, groups and colors are randomly generated for each run. To make it easy creating lots of pictures and pick the most liked, you can specifiy a number of loops how many pictures should be created. When saveImage is activated, all pictures will be stored in the data directory.

README.md

@@ -0,0 +1,208 @@
+import java.util.Date; //<>//
+
+// ==== Begin Config ====
+
+// How many groups to create
+final int groupSize = 64;
+
+// How many data points to create
+final int dataPointSize = 100 * 100;
+
+// Padding to border
+final int paddingSize = 20;
+
+// Blur strength
+final int blurStrength = 2;
+final int finalBlurStrength = 1;
+
+// Rotate color palette after each pass
+final boolean rotateColors = true;
+
+// Save image
+final boolean saveImage = true;
+
+// How many loops / images to create
+final int loopSize = 10;
+
+// ==== End Config ====
+
+PVector[] groups = new PVector[groupSize];
+PVector[] means = new PVector[groupSize];
+int[] clusters = new int[groupSize];
+color[] colors = new color[groupSize]; 
+PVector[] dataPoints = new PVector[dataPointSize];
+int dataRow = 0;
+int meansChanged = groupSize;
+int pass = 1;
+int loopsToDo = loopSize;
+long timerStart;
+
+void setup() {
+
+  // Picture size to render
+  size(800, 800);
+  
+  reset();  
+
+}
+
+void reset() {
+
+  timerStart = new Date().getTime();
+  clear();
+
+  float n1 = random(1) / groupSize;
+  float n2 = random(1) / groupSize;
+  float n3 = random(1) / groupSize;
+  
+  for(int i = 0; i < groupSize; i++) {
+    groups[i] = new PVector(getRandomWidth(), getRandomHeight());
+    colors[i] = color(noise(i * n1) * 255, noise(i * n2) * 255, noise(i * n3) * 255);
+    means[i] = new PVector(0, 0);
+    clusters[i] = 0;
+  }
+  
+  for(int i = 0; i < dataPointSize; i++) {
+    dataPoints[i] = new PVector(getRandomWidth(), getRandomHeight());
+  }
+
+  meansChanged = groupSize;
+  pass = 1;
+
+  drawDataPoints();
+
+}
+
+float getRandomWidth() {
+
+  return abs(random(width - paddingSize - paddingSize) + paddingSize); 
+
+}
+
+float getRandomHeight() {
+
+  return abs(random(height - paddingSize - paddingSize) + paddingSize); 
+
+}
+
+void drawGroups() {
+  
+  noStroke();
+
+  for(int i = 0; i < groupSize; i++) {
+    fill(colors[i]);
+    circle(groups[i].x, groups[i].y, 4);
+  }
+
+}
+
+void drawDataPoints() {
+
+  noStroke();
+
+  fill(0, 0, 255);
+  for(int i = 0; i < dataPointSize; i++) {
+    circle(dataPoints[i].x, dataPoints[i].y, 2);
+  }
+
+}
+
+int calculateMeans() {
+
+  int changes = 0; //<>//
+  
+  for(int i = 0; i < groupSize; i++) {
+    PVector mean = new PVector((int) (means[i].x / clusters[i]), (int) (means[i].y / clusters[i]));
+    means[i] = new PVector(0, 0);
+    clusters[i] = 0;
+    if(mean.x == (int) groups[i].x && mean.y == (int) groups[i].y) break;
+    groups[i] = mean;
+    changes++;
+  }
+  
+  return changes;
+
+}
+
+void rotateColors() {
+  
+  if(!rotateColors) return;
+  
+  color first = colors[0];
+  for(int i = 0, s = colors.length - 1; i < s; i++) {
+    colors[i] = colors[i + 1];
+  }
+  
+  colors[colors.length - 1] = first;
+  
+}
+
+void drawConnections() {
+  
+  for(int steps = 0, stepMax = (int) sqrt(width * height); steps < stepMax; steps++) {
+  
+    if(dataRow >= dataPointSize) {
+      long timerEnd = new Date().getTime();
+      long timeDiff = timerEnd - timerStart;
+      timerStart = timerEnd;
+      println(String.format("Loop %d/%d; Pass %d; Means %d; Took %.02fs",
+        loopSize - loopsToDo + 1, loopSize, pass++, (meansChanged = calculateMeans()), (float) timeDiff / 1000
+      ));
+      dataRow = 0;
+      rotateColors();
+      if(meansChanged > 0 && blurStrength > 0) filter(BLUR, 2);
+
+      return;
+    }
+    
+      int smallestIndex = 0;
+      float shortest = max(width, height);
+      
+      for(int j = 0; j < groupSize; j++) {
+        float distance = dist(dataPoints[dataRow].x, dataPoints[dataRow].y, groups[j].x, groups[j].y);
+        if(distance < shortest) {
+          shortest = distance;
+          smallestIndex = j;
+        } 
+      }
+      
+      clusters[smallestIndex]++;
+      means[smallestIndex] = new PVector(means[smallestIndex].x + dataPoints[dataRow].x, means[smallestIndex].y + dataPoints[dataRow].y);
+      stroke(colors[smallestIndex]);
+      line(dataPoints[dataRow].x, dataPoints[dataRow].y, groups[smallestIndex].x, groups[smallestIndex].y);
+      
+      dataRow++;
+  }
+  
+}
+
+void draw() {
+  
+  drawGroups();
+  drawConnections();
+  
+  if(meansChanged == 0) {
+    if(finalBlurStrength > 0) filter(BLUR, 1);
+    
+    if(saveImage) {
+      Date date = new Date();
+      save(String.format("data/%d_gs%d_dp%d.png",
+        date.getTime(), groupSize, dataPointSize
+      ));
+    }
+    
+    loopsToDo--;
+    println(String.format("Done; Loop %d/%d",
+      loopSize - loopsToDo, loopSize
+    ));
+    
+    if(loopsToDo <= 0) {
+      noLoop();
+      return;
+    }
+    
+    reset();
+
+  }
+
+}