@@ -135,11 +135,14 @@ java -jar target/sorting-visualizer.jar
- Morphing Shell
- Sphere (3D)
- Sphere Hoops (3D)
+ - Spheric Disparity Lines (3D)
- Disparity Sphere Hoops (3D)
- Cube (3D)
+ - Cubic Lines (3D)
- Pyramid (3D)
- Plane (3D)
- Disparity Plane (3D)
+ - Mosaic Squares
* Selecting different color gradients and creating your own
@@ -156,6 +159,9 @@ java -jar target/sorting-visualizer.jar
* Option to display a comparison table at the end of the execution
+* Controlling animation speed
+
+
* Muting Sound
diff --git a/build b/build
index 25ad200..bc6712d 100755
--- a/build
+++ b/build
@@ -1,7 +1,13 @@
#!/bin/sh
# build script for Unix-like systems
+# Use: ./build — fast incremental build (no tests, no fat jar)
+# ./build release — full clean build with fat jar (for releases)
# ensure Maven wrapper is executable
chmod +x ./mvnw
-./mvnw clean package
+if [ "$1" = "release" ]; then
+ ./mvnw clean package -Prelease
+else
+ ./mvnw package -DskipTests
+fi
diff --git a/pom.xml b/pom.xml
index df44b5f..914732c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -29,26 +29,32 @@
The default implementation ({@link #DEFAULT}) uses the probabilistic
+ * approach already present in {@code SortingAlgorithm}: always delay for small
+ * arrays, and delay proportionally otherwise, scaled by {@code delayFactor}.
+ */
+public interface DelayStrategy {
+
+ /**
+ * Returns {@code true} if a delay should be issued for the current step.
+ *
+ * @param arrayLength the current array size
+ * @param delayFactor a scale factor in the range (0, 1]; 1.0 means always
+ * delay when the other condition is satisfied
+ */
+ boolean shouldDelay(int arrayLength, double delayFactor);
+
+ /** Threshold below which every element gets its own delay frame. */
+ int DEFAULT_THRESHOLD = 2000;
+
+ /**
+ * The default probabilistic strategy: fires on every element for small
+ * arrays; fires proportionally less often as array size grows past the
+ * threshold, and always respects {@code delayFactor}.
+ */
+ DelayStrategy DEFAULT = (arrayLength, delayFactor) -> {
+ boolean stepOk = arrayLength <= DEFAULT_THRESHOLD
+ || Math.random() < (double) DEFAULT_THRESHOLD / arrayLength;
+ boolean factorOk = delayFactor >= 1.0 || Math.random() < delayFactor;
+ return stepOk && factorOk;
+ };
+}
diff --git a/src/main/java/io/github/compilerstuck/Control/HeadlessRenderContext.java b/src/main/java/io/github/compilerstuck/Control/HeadlessRenderContext.java
new file mode 100644
index 0000000..b40bdae
--- /dev/null
+++ b/src/main/java/io/github/compilerstuck/Control/HeadlessRenderContext.java
@@ -0,0 +1,71 @@
+package io.github.compilerstuck.Control;
+
+/**
+ * A trivial {@link RenderContext} implementation that does nothing. Useful for
+ * unit tests or running the application in a headless environment.
+ */
+public class HeadlessRenderContext implements RenderContext {
+ private final int width;
+ private final int height;
+
+ public HeadlessRenderContext(int width, int height) {
+ this.width = width;
+ this.height = height;
+ }
+
+ @Override
+ public void delay(int ms) {
+ // no-op
+ }
+
+ @Override
+ public void background(int rgb) {
+ // no-op
+ }
+
+ @Override
+ public void fill(int rgb) {
+ // no-op
+ }
+
+ @Override
+ public void textSize(int size) {
+ // no-op
+ }
+
+ @Override
+ public void text(String str, float x, float y) {
+ // no-op
+ }
+
+ @Override
+ public void stroke(int rgb) {
+ // no-op
+ }
+
+ @Override
+ public void rect(float x, float y, float w, float h) {
+ // no-op
+ }
+
+
+ @Override
+ public int getWidth() {
+ return width;
+ }
+
+ @Override
+ public int getHeight() {
+ return height;
+ }
+
+ @Override
+ public void line(float x1, float y1, float x2, float y2) {
+ // no-op
+ }
+
+ @Override
+ public void ellipse(float x, float y, float w, float h) {
+ // no-op
+ }
+}
diff --git a/src/main/java/io/github/compilerstuck/Control/JCheckBoxList.java b/src/main/java/io/github/compilerstuck/Control/JCheckBoxList.java
index 799f3fe..985977a 100644
--- a/src/main/java/io/github/compilerstuck/Control/JCheckBoxList.java
+++ b/src/main/java/io/github/compilerstuck/Control/JCheckBoxList.java
@@ -7,8 +7,9 @@
import java.awt.event.*;
-@SuppressWarnings("serial")
public class JCheckBoxList extends JList
+ * Each implementation defines how an {@link ArrayModel} is shuffled and how
+ * visual progress is reported. The delay between frames is driven by
+ * {@link ProcessingContext#delay(int)} so the strategy itself is independent
+ * of the Processing runtime.
+ */
+public interface ShuffleStrategy {
+
+ /**
+ * Shuffle (or otherwise arrange) the array held by {@code model} and call
+ * {@code ctx.delay(ms)} at appropriate intervals to produce a visible
+ * animation.
+ *
+ * @param model the array to operate on
+ * @param ctx the Processing context used for frame delays
+ */
+ void shuffle(ArrayModel model, ProcessingContext ctx);
+}
diff --git a/src/main/java/io/github/compilerstuck/Control/shuffle/AlmostSortedShuffleStrategy.java b/src/main/java/io/github/compilerstuck/Control/shuffle/AlmostSortedShuffleStrategy.java
new file mode 100644
index 0000000..8e93174
--- /dev/null
+++ b/src/main/java/io/github/compilerstuck/Control/shuffle/AlmostSortedShuffleStrategy.java
@@ -0,0 +1,30 @@
+package io.github.compilerstuck.Control.shuffle;
+
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.ProcessingContext;
+import io.github.compilerstuck.Control.ShuffleStrategy;
+import io.github.compilerstuck.Control.MainController;
+import io.github.compilerstuck.SortingAlgorithms.SortingAlgorithm;
+import io.github.compilerstuck.Visual.Marker;
+
+/**
+ * Performs a small number (length/10) of random swaps, leaving the array
+ * nearly sorted.
+ */
+public class AlmostSortedShuffleStrategy implements ShuffleStrategy {
+
+ @Override
+ public void shuffle(ArrayModel model, ProcessingContext ctx) {
+ int length = model.getLength();
+ int swaps = length / 10;
+ for (int i = 0; i < swaps && SortingAlgorithm.isRun(); i++) {
+ int a = (int) (Math.random() * length);
+ int b = (int) (Math.random() * length);
+ model.swap(a, b);
+ model.setMarker(a, Marker.SET);
+ model.setMarker(b, Marker.SET);
+ MainController.setCurrentOperation("Shuffling (almost).. " + (int) ((double) i / (swaps - 1) * 100) + "%");
+ RandomShuffleStrategy.maybeDelay(ctx, i, length);
+ }
+ }
+}
diff --git a/src/main/java/io/github/compilerstuck/Control/shuffle/RandomShuffleStrategy.java b/src/main/java/io/github/compilerstuck/Control/shuffle/RandomShuffleStrategy.java
new file mode 100644
index 0000000..b29374b
--- /dev/null
+++ b/src/main/java/io/github/compilerstuck/Control/shuffle/RandomShuffleStrategy.java
@@ -0,0 +1,40 @@
+package io.github.compilerstuck.Control.shuffle;
+
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.ProcessingContext;
+import io.github.compilerstuck.Control.ShuffleStrategy;
+import io.github.compilerstuck.Control.MainController;
+import io.github.compilerstuck.SortingAlgorithms.SortingAlgorithm;
+import io.github.compilerstuck.Visual.Marker;
+
+/**
+ * Fisher-Yates (random) shuffle.
+ */
+public class RandomShuffleStrategy implements ShuffleStrategy {
+
+ @Override
+ public void shuffle(ArrayModel model, ProcessingContext ctx) {
+ int length = model.getLength();
+ for (int i = 0; i < length && SortingAlgorithm.isRun(); i++) {
+ int j = (int) (Math.random() * length);
+ model.swap(i, j);
+ model.setMarker(i, Marker.SET);
+ model.setMarker(j, Marker.SET);
+ MainController.setCurrentOperation("Shuffling.. " + (int) ((double) i / (length - 1) * 100) + "%");
+ maybeDelay(ctx, i, length);
+ }
+ }
+
+ /**
+ * Fires a delay only at the {@code maxSortingTime} evenly-spaced
+ * checkpoints — avoids allocating an ArrayList on every iteration.
+ */
+ static void maybeDelay(ProcessingContext ctx, int i, int length) {
+ int maxSortingTime = 1000;
+ int step = Math.max(1, (length - 1) / (maxSortingTime - 1));
+ if (i % step == 0) {
+ int delayTime = maxSortingTime / Math.min(maxSortingTime, length);
+ ctx.delay(delayTime);
+ }
+ }
+}
diff --git a/src/main/java/io/github/compilerstuck/Control/shuffle/ReverseShuffleStrategy.java b/src/main/java/io/github/compilerstuck/Control/shuffle/ReverseShuffleStrategy.java
new file mode 100644
index 0000000..23140de
--- /dev/null
+++ b/src/main/java/io/github/compilerstuck/Control/shuffle/ReverseShuffleStrategy.java
@@ -0,0 +1,28 @@
+package io.github.compilerstuck.Control.shuffle;
+
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.ProcessingContext;
+import io.github.compilerstuck.Control.ShuffleStrategy;
+import io.github.compilerstuck.Control.MainController;
+import io.github.compilerstuck.SortingAlgorithms.SortingAlgorithm;
+import io.github.compilerstuck.Visual.Marker;
+
+/**
+ * Reverses the array in-place.
+ */
+public class ReverseShuffleStrategy implements ShuffleStrategy {
+
+ @Override
+ public void shuffle(ArrayModel model, ProcessingContext ctx) {
+ int length = model.getLength();
+ int half = length / 2;
+ for (int i = 0; i < half && SortingAlgorithm.isRun(); i++) {
+ int j = length - 1 - i;
+ model.swap(i, j);
+ model.setMarker(i, Marker.SET);
+ model.setMarker(j, Marker.SET);
+ MainController.setCurrentOperation("Shuffling (reverse).. " + (int) (i / (half - 1.) * 100) + "%");
+ RandomShuffleStrategy.maybeDelay(ctx, i, length);
+ }
+ }
+}
diff --git a/src/main/java/io/github/compilerstuck/Control/shuffle/SortedShuffleStrategy.java b/src/main/java/io/github/compilerstuck/Control/shuffle/SortedShuffleStrategy.java
new file mode 100644
index 0000000..006ea8d
--- /dev/null
+++ b/src/main/java/io/github/compilerstuck/Control/shuffle/SortedShuffleStrategy.java
@@ -0,0 +1,24 @@
+package io.github.compilerstuck.Control.shuffle;
+
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.ProcessingContext;
+import io.github.compilerstuck.Control.ShuffleStrategy;
+import io.github.compilerstuck.Control.MainController;
+import io.github.compilerstuck.SortingAlgorithms.SortingAlgorithm;
+import io.github.compilerstuck.Visual.Marker;
+
+/**
+ * Leaves the array in sorted order while still animating the pass.
+ */
+public class SortedShuffleStrategy implements ShuffleStrategy {
+
+ @Override
+ public void shuffle(ArrayModel model, ProcessingContext ctx) {
+ int length = model.getLength();
+ for (int i = 0; i < length && SortingAlgorithm.isRun(); i++) {
+ model.setMarker(i, Marker.SET);
+ MainController.setCurrentOperation("Shuffling (sorted).. " + (int) ((double) i / (length - 1) * 100) + "%");
+ RandomShuffleStrategy.maybeDelay(ctx, i, length);
+ }
+ }
+}
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/AmericanFlagSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/AmericanFlagSort.java
index fd2fdc8..4447788 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/AmericanFlagSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/AmericanFlagSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class AmericanFlagSort extends SortingAlgorithm {
- public AmericanFlagSort(ArrayController arrayController) {
+ public AmericanFlagSort(ArrayModel arrayController) {
super(arrayController);
this.name = "American Flag Sort";
alternativeSize = arrayController.getLength();
this.delayTime = 10;
}
- public AmericanFlagSort(ArrayController arrayController, int alternativeSize) {
+ public AmericanFlagSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "American Flag Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/BogoSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/BogoSort.java
index 1dd681f..4b7ff83 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/BogoSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/BogoSort.java
@@ -1,6 +1,6 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Visual.Marker;
@@ -10,7 +10,7 @@ public class BogoSort extends SortingAlgorithm {
long trycnt = 0;
- public BogoSort(ArrayController arrayController) {
+ public BogoSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Bogo Sort";
alternativeSize = arrayController.getLength();
@@ -18,7 +18,7 @@ public BogoSort(ArrayController arrayController) {
delayFactor = 0.000001;
}
- public BogoSort(ArrayController arrayController, int alternativeSize) {
+ public BogoSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Bogo Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/BubbleSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/BubbleSort.java
index 98248d6..f58bba6 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/BubbleSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/BubbleSort.java
@@ -1,11 +1,11 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class BubbleSort extends SortingAlgorithm {
- public BubbleSort(ArrayController arrayController) {
+ public BubbleSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Bubble Sort";
alternativeSize = arrayController.getLength();
@@ -14,7 +14,7 @@ public BubbleSort(ArrayController arrayController) {
}
- public BubbleSort(ArrayController arrayController, int alternativeSize) {
+ public BubbleSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Bubble Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/BucketSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/BucketSort.java
index 8ddbd0c..1bf2aea 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/BucketSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/BucketSort.java
@@ -1,13 +1,13 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import java.util.Arrays;
public class BucketSort extends SortingAlgorithm {
- public BucketSort(ArrayController arrayController) {
+ public BucketSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Bucket Sort";
alternativeSize = arrayController.getLength();
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/CombSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/CombSort.java
index b342f90..a982784 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/CombSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/CombSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class CombSort extends SortingAlgorithm {
- public CombSort(ArrayController arrayController) {
+ public CombSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Comb Sort";
alternativeSize = arrayController.getLength();
delayFactor = 0.25;
}
- public CombSort(ArrayController arrayController, int alternativeSize) {
+ public CombSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Comb Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/CountingSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/CountingSort.java
index 57fbf75..5e8553f 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/CountingSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/CountingSort.java
@@ -1,13 +1,13 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import java.util.Arrays;
public class CountingSort extends SortingAlgorithm {
- public CountingSort(ArrayController arrayController) {
+ public CountingSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Counting Sort";
alternativeSize = arrayController.getLength();
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/CycleSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/CycleSort.java
index 217cc2d..a7eba3c 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/CycleSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/CycleSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class CycleSort extends SortingAlgorithm {
- public CycleSort(ArrayController arrayController) {
+ public CycleSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Cycle Sort";
alternativeSize = arrayController.getLength();
delayTime = 8;
}
- public CycleSort(ArrayController arrayController, int alternativeSize) {
+ public CycleSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Cycle Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/DoubleSelectionSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/DoubleSelectionSort.java
index 62cdfb2..d2f6ceb 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/DoubleSelectionSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/DoubleSelectionSort.java
@@ -1,11 +1,11 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class DoubleSelectionSort extends SortingAlgorithm {
- public DoubleSelectionSort(ArrayController arrayController) {
+ public DoubleSelectionSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Double Selection Sort";
alternativeSize = arrayController.getLength();
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/GnomeSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/GnomeSort.java
index 4895ffa..9ff5357 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/GnomeSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/GnomeSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class GnomeSort extends SortingAlgorithm {
- public GnomeSort(ArrayController arrayController) {
+ public GnomeSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Gnome Sort";
alternativeSize = arrayController.getLength();
delayFactor = 1. / 50;
}
- public GnomeSort(ArrayController arrayController, int alternativeArrSize) {
+ public GnomeSort(ArrayModel arrayController, int alternativeArrSize) {
super(arrayController);
this.name = "Gnome Sort";
this.alternativeSize = alternativeArrSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/GravitySort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/GravitySort.java
index d3b1a4a..31c3d5b 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/GravitySort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/GravitySort.java
@@ -1,11 +1,11 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class GravitySort extends SortingAlgorithm {
- public GravitySort(ArrayController arrayController) {
+ public GravitySort(ArrayModel arrayController) {
super(arrayController);
this.name = "Gravity Sort";
alternativeSize = arrayController.getLength();
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/HeapSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/HeapSort.java
index 0ae673d..47b37b1 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/HeapSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/HeapSort.java
@@ -1,11 +1,11 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class HeapSort extends SortingAlgorithm {
- public HeapSort(ArrayController arrayController) {
+ public HeapSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Heap Sort";
alternativeSize = arrayController.getLength();
@@ -33,7 +33,7 @@ public void sort() {
arrayController.addRealTime(System.nanoTime() - startTime);
}
- private void heapify(ArrayController arrayController, int n, int i) {
+ private void heapify(ArrayModel arrayController, int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/InsertionSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/InsertionSort.java
index 8262ac5..b5d39eb 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/InsertionSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/InsertionSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class InsertionSort extends SortingAlgorithm {
- public InsertionSort(ArrayController arrayController) {
+ public InsertionSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Insertion Sort";
alternativeSize = arrayController.getLength();
delayTime = 10;
}
- public InsertionSort(ArrayController arrayController, int alternativeSize) {
+ public InsertionSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Insertion Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/MergeSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/MergeSort.java
index ce45b3b..e35cb56 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/MergeSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/MergeSort.java
@@ -1,11 +1,11 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class MergeSort extends SortingAlgorithm {
- public MergeSort(ArrayController arrayController) {
+ public MergeSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Merge Sort";
alternativeSize = arrayController.getLength();
@@ -22,7 +22,7 @@ public void sort() {
}
- private void sort(ArrayController arrayController, int l, int r) {
+ private void sort(ArrayModel arrayController, int l, int r) {
if (l < r && run) {
int m = (l + r) / 2;
@@ -33,7 +33,7 @@ private void sort(ArrayController arrayController, int l, int r) {
}
}
- private void merge(ArrayController arrayController, int l, int m, int r) {
+ private void merge(ArrayModel arrayController, int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
@@ -74,7 +74,7 @@ private void merge(ArrayController arrayController, int l, int m, int r) {
copyRemainingElements(arrayController, n2, R, j, k);
}
- private int copyRemainingElements(ArrayController arrayController, int n1, int[] l, int i, int k) {
+ private int copyRemainingElements(ArrayModel arrayController, int n1, int[] l, int i, int k) {
while (i < n1 && run) {
arrayController.set(k, l[i]);
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/OddEvenSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/OddEvenSort.java
index f4dacb2..3e6d717 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/OddEvenSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/OddEvenSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class OddEvenSort extends SortingAlgorithm {
- public OddEvenSort(ArrayController arrayController) {
+ public OddEvenSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Odd Even Sort";
alternativeSize = arrayController.getLength();
delayFactor = 1. / 55;
}
- public OddEvenSort(ArrayController arrayController, int alternativeSize) {
+ public OddEvenSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Odd Even Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/PigeonholeSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/PigeonholeSort.java
index 519cf21..022c598 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/PigeonholeSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/PigeonholeSort.java
@@ -1,19 +1,19 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import java.util.Arrays;
public class PigeonholeSort extends SortingAlgorithm {
- public PigeonholeSort(ArrayController arrayController) {
+ public PigeonholeSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Pigeonhole Sort";
alternativeSize = arrayController.getLength();
}
- public PigeonholeSort(ArrayController arrayController, int alternativeSize) {
+ public PigeonholeSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Pigeonhole Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortDualPivot.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortDualPivot.java
index 2b1e8be..5c93b16 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortDualPivot.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortDualPivot.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class QuickSortDualPivot extends SortingAlgorithm {
- public QuickSortDualPivot(ArrayController arrayController) {
+ public QuickSortDualPivot(ArrayModel arrayController) {
super(arrayController);
this.name = "Quick Sort (Dual Pivot)";
alternativeSize = arrayController.getLength();
delayTime = 3;
}
- public QuickSortDualPivot(ArrayController arrayController, int alternativeSize) {
+ public QuickSortDualPivot(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Quick Sort (Dual Pivot)";
this.alternativeSize = alternativeSize;
@@ -28,7 +28,7 @@ public void sort() {
arrayController.addRealTime(System.nanoTime() - startTime);
}
- private void sort(ArrayController arrayController, int left, int right) {
+ private void sort(ArrayModel arrayController, int left, int right) {
if (right > left && run) {
// Choose outermost elements as pivots
if (arrayController.get(left) > arrayController.get(right)) {
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortMiddlePivot.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortMiddlePivot.java
index b6c8828..f14f3dc 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortMiddlePivot.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/QuickSortMiddlePivot.java
@@ -1,12 +1,12 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Visual.Marker;
public class QuickSortMiddlePivot extends SortingAlgorithm {
- public QuickSortMiddlePivot(ArrayController arrayController) {
+ public QuickSortMiddlePivot(ArrayModel arrayController) {
super(arrayController);
this.name = "Quick Sort (Middle Pivot)";
alternativeSize = arrayController.getLength();
@@ -19,7 +19,7 @@ public void sort() {
arrayController.addRealTime(System.nanoTime() - startTime);
}
- private void sort(ArrayController arrayController, int start, int end) {
+ private void sort(ArrayModel arrayController, int start, int end) {
if (arrayController.getLength() == 0) {
return;
}
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/RadixLSDSortBase10.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/RadixLSDSortBase10.java
index ae62a13..d586dcb 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/RadixLSDSortBase10.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/RadixLSDSortBase10.java
@@ -1,6 +1,6 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import java.util.ArrayList;
@@ -10,13 +10,13 @@ public class RadixLSDSortBase10 extends SortingAlgorithm {
int RADIX = 10;
- public RadixLSDSortBase10(ArrayController arrayController) {
+ public RadixLSDSortBase10(ArrayModel arrayController) {
super(arrayController);
this.name = "Radix Sort (LSD) (Base " + RADIX + ")";
alternativeSize = arrayController.getLength();
}
- public RadixLSDSortBase10(ArrayController arrayController, int radix_base) {
+ public RadixLSDSortBase10(ArrayModel arrayController, int radix_base) {
super(arrayController);
RADIX = radix_base;
this.name = "Radix Sort (LSD) (Base " + RADIX + ")";
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/SelectionSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/SelectionSort.java
index 67b0df6..f658819 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/SelectionSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/SelectionSort.java
@@ -1,11 +1,11 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class SelectionSort extends SortingAlgorithm {
- public SelectionSort(ArrayController arrayController) {
+ public SelectionSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Selection Sort";
alternativeSize = arrayController.getLength();
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShakerSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShakerSort.java
index e0b1f44..b58bb08 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShakerSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShakerSort.java
@@ -1,18 +1,18 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
public class ShakerSort extends SortingAlgorithm {
- public ShakerSort(ArrayController arrayController) {
+ public ShakerSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Shaker Sort";
alternativeSize = arrayController.getLength();
delayFactor = 1. / 100;
}
- public ShakerSort(ArrayController arrayController, int alternativeSize) {
+ public ShakerSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Shaker Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShellSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShellSort.java
index f87fbba..ca9b8ee 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShellSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/ShellSort.java
@@ -1,12 +1,12 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Visual.Marker;
public class ShellSort extends SortingAlgorithm {
- public ShellSort(ArrayController arrayController) {
+ public ShellSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Shell Sort";
alternativeSize = arrayController.getLength();
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithm.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithm.java
index 9b35d91..1d89ee7 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithm.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithm.java
@@ -1,13 +1,14 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.DelayStrategy;
import io.github.compilerstuck.Control.MainController;
-import processing.core.PApplet;
+import io.github.compilerstuck.Control.ProcessingContext;
import io.github.compilerstuck.Visual.Marker;
public abstract class SortingAlgorithm {
- protected PApplet proc;
+ protected ProcessingContext proc;
protected String name;
protected boolean delay;
protected int delayTime = 1; //ms
@@ -16,13 +17,17 @@ public abstract class SortingAlgorithm {
protected boolean selected = true;
protected long startTime;
protected double delayFactor = 1.;
- private double elementsDelayThreshold = 2000;
+ private DelayStrategy delayStrategy = DelayStrategy.DEFAULT;
- ArrayController arrayController;
+ ArrayModel arrayController;
- public SortingAlgorithm(ArrayController arrayController) {
- proc = MainController.processing;
+ public SortingAlgorithm(ArrayModel arrayController) {
+ this(arrayController, MainController.processing);
+ }
+
+ public SortingAlgorithm(ArrayModel arrayController, ProcessingContext proc) {
+ this.proc = proc;
this.arrayController = arrayController;
delay = true;
}
@@ -62,9 +67,16 @@ public void setDelayTime(int delayTime) {
this.delayTime = delayTime;
}
+ public void setDelayFactor(double delayFactor) {
+ this.delayFactor = delayFactor;
+ }
+
+ public void setDelayStrategy(DelayStrategy delayStrategy) {
+ this.delayStrategy = delayStrategy;
+ }
+
public void delay(int[] markers) {
- // Delay if: delay is enabled, the array is small enough or a random number is smaller than the probability of delaying, and the delay factor is 1 or a random number is smaller than the delay factor
- if (delay && (arrayController.getLength() <= elementsDelayThreshold || Math.random() < elementsDelayThreshold / arrayController.getLength()) && (delayFactor == 1 || Math.random() < delayFactor)) {
+ if (delay && delayStrategy.shouldDelay(arrayController.getLength(), delayFactor)) {
arrayController.addRealTime(System.nanoTime() - startTime);
for (int i : markers) {
diff --git a/src/main/java/io/github/compilerstuck/SortingAlgorithms/TimSort.java b/src/main/java/io/github/compilerstuck/SortingAlgorithms/TimSort.java
index a5cbfa4..b8fc0a2 100644
--- a/src/main/java/io/github/compilerstuck/SortingAlgorithms/TimSort.java
+++ b/src/main/java/io/github/compilerstuck/SortingAlgorithms/TimSort.java
@@ -1,19 +1,19 @@
package io.github.compilerstuck.SortingAlgorithms;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import java.util.Random;
public class TimSort extends SortingAlgorithm {
- public TimSort(ArrayController arrayController) {
+ public TimSort(ArrayModel arrayController) {
super(arrayController);
this.name = "Tim Sort";
alternativeSize = arrayController.getLength();
}
- public TimSort(ArrayController arrayController, int alternativeSize) {
+ public TimSort(ArrayModel arrayController, int alternativeSize) {
super(arrayController);
this.name = "Tim Sort";
this.alternativeSize = alternativeSize;
diff --git a/src/main/java/io/github/compilerstuck/Sound/HeadlessSound.java b/src/main/java/io/github/compilerstuck/Sound/HeadlessSound.java
new file mode 100644
index 0000000..c7a485f
--- /dev/null
+++ b/src/main/java/io/github/compilerstuck/Sound/HeadlessSound.java
@@ -0,0 +1,23 @@
+package io.github.compilerstuck.Sound;
+
+import io.github.compilerstuck.Control.ArrayModel;
+
+/**
+ * No-op sound implementation used when audio output is not desired (e.g. in
+ * tests or headless runs).
+ */
+public class HeadlessSound extends Sound {
+ public HeadlessSound(ArrayModel arrayController) {
+ super(arrayController);
+ }
+
+ @Override
+ public void playSound(int value) {
+ // nothing
+ }
+
+ @Override
+ public void mute(boolean mute) {
+ // ignore
+ }
+}
diff --git a/src/main/java/io/github/compilerstuck/Sound/MidiSys.java b/src/main/java/io/github/compilerstuck/Sound/MidiSys.java
index 68ac60d..ecaf02a 100644
--- a/src/main/java/io/github/compilerstuck/Sound/MidiSys.java
+++ b/src/main/java/io/github/compilerstuck/Sound/MidiSys.java
@@ -1,8 +1,9 @@
package io.github.compilerstuck.Sound;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Visual.Marker;
+import processing.core.PApplet;
import javax.sound.midi.*;
@@ -12,9 +13,9 @@ public class MidiSys extends Sound {
private final MidiChannel synthesizerChannel;
- public MidiSys(ArrayController arrayController) throws MidiUnavailableException {
+ public MidiSys(ArrayModel arrayController) throws MidiUnavailableException {
super(arrayController);
- proc = MainController.processing;
+ proc = (PApplet) MainController.processing;
Synthesizer synthesizer = MidiSystem.getSynthesizer();
synthesizer.open();
synthesizer.loadAllInstruments(synthesizer.getDefaultSoundbank());
diff --git a/src/main/java/io/github/compilerstuck/Sound/MinimSound.java b/src/main/java/io/github/compilerstuck/Sound/MinimSound.java
index a2d99c3..ae8fc0b 100644
--- a/src/main/java/io/github/compilerstuck/Sound/MinimSound.java
+++ b/src/main/java/io/github/compilerstuck/Sound/MinimSound.java
@@ -2,8 +2,9 @@
import ddf.minim.AudioOutput;
import ddf.minim.Minim;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.MainController;
+import processing.core.PApplet;
public class MinimSound extends Sound {
@@ -13,9 +14,9 @@ public class MinimSound extends Sound {
double timegone;
//Used this sound earlier in development
- public MinimSound(ArrayController arrayController) {
+ public MinimSound(ArrayModel arrayController) {
super((arrayController));
- proc = MainController.processing;
+ proc = (PApplet) MainController.processing;
minim = new Minim(proc);
out = minim.getLineOut(Minim.MONO);
timegone = System.nanoTime();
diff --git a/src/main/java/io/github/compilerstuck/Sound/Sound.java b/src/main/java/io/github/compilerstuck/Sound/Sound.java
index 5f5964e..c76d127 100644
--- a/src/main/java/io/github/compilerstuck/Sound/Sound.java
+++ b/src/main/java/io/github/compilerstuck/Sound/Sound.java
@@ -1,14 +1,14 @@
package io.github.compilerstuck.Sound;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
import processing.core.PApplet;
public abstract class Sound {
protected PApplet proc;
- ArrayController arrayController;
+ ArrayModel arrayController;
protected boolean isMuted;
- public Sound(ArrayController arrayController) {
+ public Sound(ArrayModel arrayController) {
this.arrayController = arrayController;
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Bars.java b/src/main/java/io/github/compilerstuck/Visual/Bars.java
index a325f72..56a08d3 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Bars.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Bars.java
@@ -1,17 +1,18 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class Bars extends Visualization {
- public Bars(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Bars(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Bars";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Circle.java b/src/main/java/io/github/compilerstuck/Visual/Circle.java
index 8cd39ff..865dd15 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Circle.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Circle.java
@@ -1,6 +1,7 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +11,8 @@ public class Circle extends Visualization {
int radius;
- public Circle(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Circle(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Circle";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/ColorGradientGraph.java b/src/main/java/io/github/compilerstuck/Visual/ColorGradientGraph.java
index da8ae10..43e5e67 100644
--- a/src/main/java/io/github/compilerstuck/Visual/ColorGradientGraph.java
+++ b/src/main/java/io/github/compilerstuck/Visual/ColorGradientGraph.java
@@ -1,17 +1,18 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class ColorGradientGraph extends Visualization {
- public ColorGradientGraph(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public ColorGradientGraph(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Color Gradient Graph";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Cube.java b/src/main/java/io/github/compilerstuck/Visual/Cube.java
index f63df26..e4b25ed 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Cube.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Cube.java
@@ -1,10 +1,11 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
import java.util.ArrayList;
@@ -17,8 +18,8 @@ public class Cube extends Visualization {
int radius;
static float aa = 0;
- public Cube(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Cube(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Cube";
}
@@ -27,7 +28,7 @@ public Cube(ArrayController arrayController, ColorGradient colorGradient, Sound
public void update() {
super.update();
- proc.lights();
+ ((PApplet)proc).lights();
radius = (int) (min(screenHeight, screenWidth) / 3.5);
@@ -37,7 +38,7 @@ public void update() {
MainController.updateArraySize(nextN * nextN * nextN); // Update arraySize
}
- aa -= PApplet.PI / (10 * proc.frameRate);
+ aa -= PApplet.PI / (10 * ((PApplet)proc).frameRate);
int xSize = (int) (Math.pow(arrayController.getLength(), 1 / 3.) + 0.1);
int xCnt = 0;
@@ -54,8 +55,8 @@ public void update() {
Color color = colorGradient.getMarkerColor(arrayController.get(i), arrayController.getMarker(i));
- proc.stroke(color.getRGB());
- proc.fill(color.getRGB());
+ ((PApplet)proc).stroke(color.getRGB());
+ ((PApplet)proc).fill(color.getRGB());
if (arrayController.getMarker(arrayController.get(i)) == Marker.SET) {
sound.playSound(arrayController.get(i));
@@ -100,23 +101,23 @@ public void update() {
if (colors.size() != arrayController.getLength()) return;
Color color = colors.get(i);
- proc.stroke(color.getRGB(), 255f);
- //proc.noStroke();
- proc.fill(color.getRGB(), 120f);
+ ((PApplet)proc).stroke(color.getRGB(), 255f);
+ //((PApplet)proc).noStroke();
+ ((PApplet)proc).fill(color.getRGB(), 120f);
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
//set screen center
- proc.translate((float) screenWidth / 2, (float) screenHeight / 2 -(int) (min(screenHeight, screenWidth) / 10), -(int) (min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) screenHeight / 2 -(int) (min(screenHeight, screenWidth) / 10), -(int) (min(screenHeight, screenWidth) / 10));
//set circle position
- proc.translate(xCords.get(i), yCords.get(i), zCords.get(i));
+ ((PApplet)proc).translate(xCords.get(i), yCords.get(i), zCords.get(i));
//proc.ellipse(0, 0, sizes.get(i), sizes.get(i));
- proc.rotateX(45);
- proc.rotateY(0);
- proc.rotateZ(-aa);
- proc.box(sizes.get(i), sizes.get(i), sizes.get(i));
- proc.popMatrix();
+ ((PApplet)proc).rotateX(45);
+ ((PApplet)proc).rotateY(0);
+ ((PApplet)proc).rotateZ(-aa);
+ ((PApplet)proc).box(sizes.get(i), sizes.get(i), sizes.get(i));
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/CubicLines.java b/src/main/java/io/github/compilerstuck/Visual/CubicLines.java
index 621b232..7f15f44 100644
--- a/src/main/java/io/github/compilerstuck/Visual/CubicLines.java
+++ b/src/main/java/io/github/compilerstuck/Visual/CubicLines.java
@@ -1,10 +1,11 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
import java.util.ArrayList;
@@ -17,8 +18,8 @@ public class CubicLines extends Visualization {
int radius;
static float aa = 0;
- public CubicLines(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public CubicLines(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Cubic Lines";
}
@@ -27,7 +28,7 @@ public CubicLines(ArrayController arrayController, ColorGradient colorGradient,
public void update() {
super.update();
- proc.lights();
+ ((PApplet)proc).lights();
radius = (int) (min(screenHeight, screenWidth) / 3.5);
@@ -37,7 +38,7 @@ public void update() {
MainController.updateArraySize(nextN * nextN * nextN); // Update arraySize
}
- aa -= PApplet.PI / (10 * proc.frameRate);
+ aa -= PApplet.PI / (10 * ((PApplet)proc).frameRate);
int xSize = (int) (Math.pow(arrayController.getLength(), 1 / 3.) + 0.1);
int xCnt = 0;
@@ -54,8 +55,8 @@ public void update() {
Color color = colorGradient.getMarkerColor(arrayController.get(i), arrayController.getMarker(i));
- proc.stroke(color.getRGB());
- proc.fill(color.getRGB());
+ ((PApplet)proc).stroke(color.getRGB());
+ ((PApplet)proc).fill(color.getRGB());
if (arrayController.getMarker(arrayController.get(i)) == Marker.SET) {
sound.playSound(arrayController.get(i));
@@ -100,25 +101,25 @@ public void update() {
if (colors.size() != arrayController.getLength()) return;
Color color = colors.get(i);
- proc.stroke(color.getRGB(), 255f);
- proc.fill(color.getRGB(), 255f);
+ ((PApplet)proc).stroke(color.getRGB(), 255f);
+ ((PApplet)proc).fill(color.getRGB(), 255f);
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
- proc.translate((float) screenWidth / 2, (float) screenHeight / 2 -(int) (min(screenHeight, screenWidth) / 10), -(int) (min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) screenHeight / 2 -(int) (min(screenHeight, screenWidth) / 10), -(int) (min(screenHeight, screenWidth) / 10));
- proc.rotateY(0);
+ ((PApplet)proc).rotateY(0);
if (i == arrayController.get(i)) {
- proc.translate(xCords.get(i), yCords.get(i), zCords.get(i));
- proc.circle(0, 0, 2);
+ ((PApplet)proc).translate(xCords.get(i), yCords.get(i), zCords.get(i));
+ ((PApplet)proc).circle(0, 0, 2);
}else{
- proc.line(xCords.get(i), yCords.get(i), zCords.get(i), xCords.get(arrayController.get(i)), yCords.get(arrayController.get(i)), zCords.get(arrayController.get(i)));
+ ((PApplet)proc).line(xCords.get(i), yCords.get(i), zCords.get(i), xCords.get(arrayController.get(i)), yCords.get(arrayController.get(i)), zCords.get(arrayController.get(i)));
}
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityChords.java b/src/main/java/io/github/compilerstuck/Visual/DisparityChords.java
index b862520..4247a68 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityChords.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityChords.java
@@ -1,6 +1,7 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +11,8 @@ public class DisparityChords extends Visualization {
int radius;
- public DisparityChords(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityChords(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Chords";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityCircle.java b/src/main/java/io/github/compilerstuck/Visual/DisparityCircle.java
index 7782380..6c0ad85 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityCircle.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityCircle.java
@@ -1,6 +1,7 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +11,8 @@ public class DisparityCircle extends Visualization {
int radius;
- public DisparityCircle(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityCircle(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Circle";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatter.java b/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatter.java
index 55994b2..de42764 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatter.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatter.java
@@ -1,6 +1,8 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +12,8 @@ public class DisparityCircleScatter extends Visualization {
int radius;
- public DisparityCircleScatter(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityCircleScatter(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Circle Scatter";
}
@@ -27,7 +29,7 @@ public void update() {
Color color = colorGradient.getMarkerColor(arrayController.get(i), arrayController.getMarker(i));
//proc.stroke(color.getRGB());
- proc.noStroke();
+ ((PApplet)proc).noStroke();
proc.fill(color.getRGB());
if (arrayController.getMarker(i) == Marker.SET) {
@@ -44,7 +46,7 @@ public void update() {
int x = (screenWidth / 2) + (int) (radius * barHeight * Math.sin(phase));
int y = (screenHeight / 2) - (int) (radius * barHeight * Math.cos(phase));
- proc.circle(x, y, 4); //Swirl dots
+ ((PApplet)proc).circle(x, y, 4); //Swirl dots
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatterLinked.java b/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatterLinked.java
index 581742b..7ff7b8b 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatterLinked.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityCircleScatterLinked.java
@@ -1,6 +1,7 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +11,8 @@ public class DisparityCircleScatterLinked extends Visualization {
int radius;
- public DisparityCircleScatterLinked(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityCircleScatterLinked(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Circle Scatter Linked";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityGraph.java b/src/main/java/io/github/compilerstuck/Visual/DisparityGraph.java
index 9e9b221..f917955 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityGraph.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityGraph.java
@@ -1,17 +1,18 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class DisparityGraph extends Visualization {
- public DisparityGraph(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityGraph(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Graph";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityGraphMirrored.java b/src/main/java/io/github/compilerstuck/Visual/DisparityGraphMirrored.java
index 519f3e7..cc2ab65 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityGraphMirrored.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityGraphMirrored.java
@@ -1,16 +1,17 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class DisparityGraphMirrored extends Visualization {
- public DisparityGraphMirrored(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityGraphMirrored(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Graph Mirrored";
}
@@ -35,7 +36,7 @@ public void update() {
arrayController.setMarker(i, Marker.NORMAL);
- proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), proc.height / 2f + barHeight / 2f, rectWidth, -1 * barHeight); //MirroredDisparityGraph
+ proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), proc.getHeight() / 2f + barHeight / 2f, rectWidth, -1 * barHeight); //MirroredDisparityGraph
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparityPlane.java b/src/main/java/io/github/compilerstuck/Visual/DisparityPlane.java
index 862565d..73b7cf4 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparityPlane.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparityPlane.java
@@ -1,10 +1,11 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import processing.core.PConstants;
import static java.lang.Math.floor;
@@ -19,8 +20,8 @@ public class DisparityPlane extends Visualization {
float squareRoot;
- public DisparityPlane(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparityPlane(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Disparity Plane";
}
@@ -31,8 +32,8 @@ public void update() {
//int rectWidth = (screenWidth - (arrayController.getLength() - 1)) / arrayController.getLength();
int radius = (int) (Math.min(screenHeight, screenWidth) / 1.2);
- angle += PApplet.PI / (15 * proc.frameRate);
- proc.lights();
+ angle += PApplet.PI / (15 * ((PApplet)proc).frameRate);
+ ((PApplet)proc).lights();
if (Math.pow(floor(Math.pow(arrayController.getLength(), 1 / 2.)), 2.) != arrayController.getLength()) {
@@ -64,21 +65,21 @@ public void update() {
//Classic bar: proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight, rectWidth, -1 * barHeight);
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
- proc.translate((float) screenWidth / 2, (float) (screenHeight / 2.5), -(int) (Math.min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) (screenHeight / 2.5), -(int) (Math.min(screenHeight, screenWidth) / 10));
- proc.rotateX(PConstants.PI/3);
- proc.rotateZ(angle);
+ ((PApplet)proc).rotateX(PConstants.PI/3);
+ ((PApplet)proc).rotateZ(angle);
- // Pyramid: proc.translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
+ // Pyramid: ((PApplet)proc).translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
- proc.translate(-radius/2 + (int)floor(i/squareRoot) * tileDim, -radius/2 + i%squareRoot * tileDim, barHeight);
+ ((PApplet)proc).translate(-radius/2 + (int)floor(i/squareRoot) * tileDim, -radius/2 + i%squareRoot * tileDim, barHeight);
proc.rect(-tileDim/2, -tileDim/2, tileDim, tileDim);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparitySphereHoops.java b/src/main/java/io/github/compilerstuck/Visual/DisparitySphereHoops.java
index fc92e61..b10d609 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparitySphereHoops.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparitySphereHoops.java
@@ -1,9 +1,10 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import processing.core.PConstants;
import java.lang.Math;
@@ -15,8 +16,8 @@ public class DisparitySphereHoops extends Visualization {
float angle = 0;
- public DisparitySphereHoops(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparitySphereHoops(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Disparity Sphere Hoops";
}
@@ -27,8 +28,8 @@ public void update() {
//int rectWidth = (screenWidth - (arrayController.getLength() - 1)) / arrayController.getLength();
int radius = (int) (Math.min(screenHeight, screenWidth) / 1.1);
- angle -= PApplet.PI / (15 * proc.frameRate);
- proc.lights();
+ angle -= PApplet.PI / (15 * ((PApplet)proc).frameRate);
+ ((PApplet)proc).lights();
for (int i = 0; i < arrayController.getLength(); i++) {
@@ -48,23 +49,23 @@ public void update() {
proc.stroke(color.getRGB());
proc.fill(color.getRGB());
- proc.noFill();
+ ((PApplet)proc).noFill();
//proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight, rectWidth, -1 * barHeight); //Classic bar
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
- proc.translate((float) screenWidth / 2, (float) (screenHeight / 2), -(int) (Math.min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) (screenHeight / 2), -(int) (Math.min(screenHeight, screenWidth) / 10));
- proc.rotateX(PConstants.PI/3);
- //proc.rotateY(angle);
+ ((PApplet)proc).rotateX(PConstants.PI/3);
+ //((PApplet)proc).rotateY(angle);
- proc.translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
+ ((PApplet)proc).translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
- proc.circle(0, 0, sphere_wi);
+ ((PApplet)proc).circle(0, 0, sphere_wi);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/DisparitySquareScatter.java b/src/main/java/io/github/compilerstuck/Visual/DisparitySquareScatter.java
index bad0c25..ae6a599 100644
--- a/src/main/java/io/github/compilerstuck/Visual/DisparitySquareScatter.java
+++ b/src/main/java/io/github/compilerstuck/Visual/DisparitySquareScatter.java
@@ -1,6 +1,8 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +12,8 @@ public class DisparitySquareScatter extends Visualization {
int sideLength;
- public DisparitySquareScatter(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public DisparitySquareScatter(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Disparity Square Scatter";
}
@@ -28,7 +30,7 @@ public void update() {
Color color = colorGradient.getMarkerColor(arrayController.get(i), arrayController.getMarker(i));
//proc.stroke(color.getRGB());
- proc.noStroke();
+ ((PApplet)proc).noStroke();
proc.fill(color.getRGB());
if (arrayController.getMarker(i) == Marker.SET) {
@@ -61,7 +63,7 @@ public void update() {
x *= barHeight;
y *= barHeight;
- proc.circle(centerX + x, centerY + y, 6);
+ ((PApplet)proc).circle(centerX + x, centerY + y, 6);
}
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Hoops.java b/src/main/java/io/github/compilerstuck/Visual/Hoops.java
index 0da2286..89978d2 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Hoops.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Hoops.java
@@ -1,9 +1,10 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
@@ -11,8 +12,8 @@ public class Hoops extends Visualization {
int radius;
- public Hoops(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Hoops(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Hoops";
}
@@ -25,7 +26,7 @@ public void update() {
proc.stroke(color.getRGB());
- proc.noFill();
+ ((PApplet)proc).noFill();
if (arrayController.getMarker(i) == Marker.SET) {
sound.playSound(i);
diff --git a/src/main/java/io/github/compilerstuck/Visual/HorizontalPyramid.java b/src/main/java/io/github/compilerstuck/Visual/HorizontalPyramid.java
index d75806a..5e92761 100644
--- a/src/main/java/io/github/compilerstuck/Visual/HorizontalPyramid.java
+++ b/src/main/java/io/github/compilerstuck/Visual/HorizontalPyramid.java
@@ -1,16 +1,17 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class HorizontalPyramid extends Visualization {
- public HorizontalPyramid(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public HorizontalPyramid(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Horizontal Pyramid";
}
@@ -37,7 +38,7 @@ public void update() {
arrayController.setMarker(i, Marker.NORMAL);
- proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), proc.height / 2f + barHeight / 2f, rectWidth, -1 * barHeight); //Horizontal Pyramid
+ proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), proc.getHeight() / 2f + barHeight / 2f, rectWidth, -1 * barHeight); //Horizontal Pyramid
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/ImageHorizontal.java b/src/main/java/io/github/compilerstuck/Visual/ImageHorizontal.java
index 21de459..b423840 100644
--- a/src/main/java/io/github/compilerstuck/Visual/ImageHorizontal.java
+++ b/src/main/java/io/github/compilerstuck/Visual/ImageHorizontal.java
@@ -1,6 +1,8 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -9,16 +11,16 @@
public class ImageHorizontal extends Visualization {
private PImage img;
- public ImageHorizontal(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public ImageHorizontal(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Image - Horizontal Sorting";
setImg("dummy-image.jpg");
}
@Override
public void update() {
- this.screenHeight = proc.height;
- this.screenWidth = proc.width;
+ this.screenHeight = proc.getHeight();
+ this.screenWidth = proc.getWidth();
if(arrayController.getLength()>img.pixelHeight){
MainController.updateArraySize(img.pixelHeight);
@@ -41,7 +43,7 @@ else if (img.pixelHeight % arrayController.getLength() > 0) {
proc.background(15);
- proc.loadPixels();
+ ((PApplet)proc).loadPixels();
img.loadPixels();
int imgPartWidth = screenHeight / arrayController.getLength();
@@ -56,9 +58,9 @@ else if (img.pixelHeight % arrayController.getLength() > 0) {
int loc = x + y * img.pixelWidth;
- float r = proc.red(img.pixels[loc]);
- float g = proc.green(img.pixels[loc]);
- float b = proc.blue(img.pixels[loc]);
+ float r = ((PApplet)proc).red(img.pixels[loc]);
+ float g = ((PApplet)proc).green(img.pixels[loc]);
+ float b = ((PApplet)proc).blue(img.pixels[loc]);
// If Marker.SET is set, set the pixel to white
if (arrayController.getMarker(i) == Marker.SET) {
@@ -67,7 +69,7 @@ else if (img.pixelHeight % arrayController.getLength() > 0) {
b = 255;
}
- proc.pixels[realLoc] = proc.color(r, g, b);
+ ((PApplet)proc).pixels[realLoc] = ((PApplet)proc).color(r, g, b);
}
}
@@ -82,7 +84,7 @@ else if (img.pixelHeight % arrayController.getLength() > 0) {
}
- proc.updatePixels();
+ ((PApplet)proc).updatePixels();
proc.fill(255);
proc.textSize((int) (25. / 1280 * screenWidth));
@@ -92,13 +94,13 @@ else if (img.pixelHeight % arrayController.getLength() > 0) {
public boolean setImg(String imagePath) {
boolean imageFound = true;
- proc.getSurface().setResizable(false); // Enable window resizing
+ ((PApplet)proc).getSurface().setResizable(false); // Enable window resizing
try {
- img = proc.loadImage(imagePath);
+ img = ((PApplet)proc).loadImage(imagePath);
// Resize the image to match the window size
- img.resize(proc.width, proc.height);
+ img.resize(proc.getWidth(), proc.getHeight());
} catch (Exception e) {
imageFound = false;
diff --git a/src/main/java/io/github/compilerstuck/Visual/ImageVertical.java b/src/main/java/io/github/compilerstuck/Visual/ImageVertical.java
index 756530c..fa5542e 100644
--- a/src/main/java/io/github/compilerstuck/Visual/ImageVertical.java
+++ b/src/main/java/io/github/compilerstuck/Visual/ImageVertical.java
@@ -1,6 +1,8 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,16 +12,16 @@ public class ImageVertical extends Visualization {
PImage img;
- public ImageVertical(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public ImageVertical(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Image - Vertical Sorting";
setImg("dummy-image.jpg");
}
@Override
public void update() {
- this.screenHeight = proc.height;
- this.screenWidth = proc.width;
+ this.screenHeight = proc.getHeight();
+ this.screenWidth = proc.getWidth();
if(arrayController.getLength()>img.pixelWidth){
MainController.updateArraySize(img.pixelWidth);
@@ -42,7 +44,7 @@ else if (img.pixelWidth % arrayController.getLength() > 0) {
proc.background(15);
- proc.loadPixels();
+ ((PApplet)proc).loadPixels();
img.loadPixels();
int imgPartHeight = screenWidth / arrayController.getLength();
@@ -56,9 +58,9 @@ else if (img.pixelWidth % arrayController.getLength() > 0) {
int realLoc = (x - pos + i * imgPartHeight) + y * img.pixelWidth;
int loc = x + y * img.pixelWidth;
- float r = proc.red(img.pixels[loc]);
- float g = proc.green(img.pixels[loc]);
- float b = proc.blue(img.pixels[loc]);
+ float r = ((PApplet)proc).red(img.pixels[loc]);
+ float g = ((PApplet)proc).green(img.pixels[loc]);
+ float b = ((PApplet)proc).blue(img.pixels[loc]);
// If Marker.SET is set, set the pixel to white
if (arrayController.getMarker(i) == Marker.SET) {
@@ -67,7 +69,7 @@ else if (img.pixelWidth % arrayController.getLength() > 0) {
b = 255;
}
- proc.pixels[realLoc] = proc.color(r, g, b);
+ ((PApplet)proc).pixels[realLoc] = ((PApplet)proc).color(r, g, b);
}
}
@@ -82,7 +84,7 @@ else if (img.pixelWidth % arrayController.getLength() > 0) {
}
- proc.updatePixels();
+ ((PApplet)proc).updatePixels();
proc.fill(255);
proc.textSize((int) (25. / 1280 * screenWidth));
@@ -93,13 +95,13 @@ else if (img.pixelWidth % arrayController.getLength() > 0) {
public boolean setImg(String imagePath) {
boolean imageFound = true;
- proc.getSurface().setResizable(false); // Enable window resizing
+ ((PApplet)proc).getSurface().setResizable(false); // Enable window resizing
try {
- img = proc.loadImage(imagePath);
+ img = ((PApplet)proc).loadImage(imagePath);
// Resize the image to match the window size
- img.resize(proc.width, proc.height);
+ img.resize(proc.getWidth(), proc.getHeight());
} catch (Exception e) {
imageFound = false;
diff --git a/src/main/java/io/github/compilerstuck/Visual/MorphingShell.java b/src/main/java/io/github/compilerstuck/Visual/MorphingShell.java
index a9512b7..f1f86da 100644
--- a/src/main/java/io/github/compilerstuck/Visual/MorphingShell.java
+++ b/src/main/java/io/github/compilerstuck/Visual/MorphingShell.java
@@ -1,9 +1,10 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import static java.lang.Math.min;
@@ -16,33 +17,33 @@ public class MorphingShell extends Visualization {
float angle = 0;
- public MorphingShell(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public MorphingShell(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Morphing Shell";
}
@Override
public void update() {
super.update();
- proc.lights();
+ ((PApplet)proc).lights();
radius = Math.min(screenHeight, screenWidth) / 2;
- aa += PApplet.PI / (proc.frameRate * 10);
+ aa += PApplet.PI / (((PApplet)proc).frameRate * 10);
int colSize = (int) Math.sqrt(arrayController.getLength());
int rowCnt = 0;
int colCnt = 0;
- angle += PApplet.PI / (7.5 * proc.frameRate);
+ angle += PApplet.PI / (7.5 * ((PApplet)proc).frameRate);
for (int i = 0; i < arrayController.getLength(); i++) {
Color color = colorGradient.getMarkerColor(arrayController.get(i), arrayController.getMarker(i));
- proc.noStroke();
- proc.fill(color.getRGB(), (float) (255.));
+ ((PApplet)proc).noStroke();
+ ((PApplet)proc).fill(color.getRGB(), (float) (255.));
if (arrayController.getMarker(rowCnt + colCnt * colSize) == Marker.SET) {
sound.playSound(rowCnt + colCnt * colSize);
@@ -63,16 +64,16 @@ public void update() {
//y = screenHeight / 2. + y / 2;
- proc.pushMatrix();
- proc.translate((float) screenWidth / 4, (float) screenHeight / 2, -(int) (min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).pushMatrix();
+ ((PApplet)proc).translate((float) screenWidth / 4, (float) screenHeight / 2, -(int) (min(screenHeight, screenWidth) / 10));
- //proc.rotateX(PConstants.PI/3);
- //proc.rotateX(angle);
+ //((PApplet)proc).rotateX(PConstants.PI/3);
+ //((PApplet)proc).rotateX(angle);
- proc.translate(y/2, x/2, z);
+ ((PApplet)proc).translate(y/2, x/2, z);
proc.ellipse(0, 0, 15, 15);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
diff --git a/src/main/java/io/github/compilerstuck/Visual/MosaicSquares.java b/src/main/java/io/github/compilerstuck/Visual/MosaicSquares.java
index 96864af..83bf3e1 100644
--- a/src/main/java/io/github/compilerstuck/Visual/MosaicSquares.java
+++ b/src/main/java/io/github/compilerstuck/Visual/MosaicSquares.java
@@ -1,6 +1,7 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -13,8 +14,8 @@
public class MosaicSquares extends Visualization {
- public MosaicSquares(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public MosaicSquares(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Mosaic Squares";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/NumberPlot.java b/src/main/java/io/github/compilerstuck/Visual/NumberPlot.java
index 72d7515..21ecf5b 100644
--- a/src/main/java/io/github/compilerstuck/Visual/NumberPlot.java
+++ b/src/main/java/io/github/compilerstuck/Visual/NumberPlot.java
@@ -1,16 +1,17 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class NumberPlot extends Visualization {
- public NumberPlot(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public NumberPlot(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Number Plot";
}
@@ -34,7 +35,7 @@ public void update() {
arrayController.setMarker(i, Marker.NORMAL);
- proc.text(arrayController.get(i) + 1, PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight - barHeight); //Classic
+ proc.text(String.valueOf(arrayController.get(i) + 1), PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight - barHeight); //Classic
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Phyllotaxis.java b/src/main/java/io/github/compilerstuck/Visual/Phyllotaxis.java
index a511a73..c7ad383 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Phyllotaxis.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Phyllotaxis.java
@@ -1,9 +1,10 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
@@ -15,8 +16,8 @@ public class Phyllotaxis extends Visualization {
int radius;
int c;
- public Phyllotaxis(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Phyllotaxis(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Phyllotaxis";
}
@@ -46,7 +47,7 @@ public void update() {
float x = (float) (r * cos(a));
float y = (float) (r * sin(a));
- proc.circle(screenWidth / 2f + x, screenHeight / 2f + y, 5); //Swirl dots
+ ((PApplet)proc).circle(screenWidth / 2f + x, screenHeight / 2f + y, 5); //Swirl dots
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Plane.java b/src/main/java/io/github/compilerstuck/Visual/Plane.java
index 1c89220..9d9953a 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Plane.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Plane.java
@@ -1,10 +1,11 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import processing.core.PConstants;
import static java.lang.Math.floor;
@@ -19,8 +20,8 @@ public class Plane extends Visualization {
float squareRoot;
- public Plane(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Plane(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Plane";
}
@@ -31,8 +32,8 @@ public void update() {
//int rectWidth = (screenWidth - (arrayController.getLength() - 1)) / arrayController.getLength();
int radius = (int) (Math.min(screenHeight, screenWidth) / 1.2);
- angle += PApplet.PI / (15 * proc.frameRate);
- proc.lights();
+ angle += PApplet.PI / (15 * ((PApplet)proc).frameRate);
+ ((PApplet)proc).lights();
if (Math.pow(floor(Math.pow(arrayController.getLength(), 1 / 2.)), 2.) != arrayController.getLength()) {
@@ -61,21 +62,21 @@ public void update() {
//Classic bar: proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight, rectWidth, -1 * barHeight);
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
- proc.translate((float) screenWidth / 2, (float) (screenHeight / 2.5), -(int) (Math.min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) (screenHeight / 2.5), -(int) (Math.min(screenHeight, screenWidth) / 10));
- proc.rotateX(PConstants.PI/3);
- proc.rotateZ(angle);
+ ((PApplet)proc).rotateX(PConstants.PI/3);
+ ((PApplet)proc).rotateZ(angle);
- // Pyramid: proc.translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
+ // Pyramid: ((PApplet)proc).translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
- proc.translate(-radius/2 + (int)floor(i/squareRoot) * tileDim, -radius/2 + i%squareRoot * tileDim, 0);
+ ((PApplet)proc).translate(-radius/2 + (int)floor(i/squareRoot) * tileDim, -radius/2 + i%squareRoot * tileDim, 0);
proc.rect(-tileDim/2, -tileDim/2, tileDim, tileDim);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Pyramid.java b/src/main/java/io/github/compilerstuck/Visual/Pyramid.java
index faa44dd..e06ff1f 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Pyramid.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Pyramid.java
@@ -1,9 +1,10 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import processing.core.PConstants;
import java.lang.Math;
@@ -15,8 +16,8 @@ public class Pyramid extends Visualization {
float angle = 0;
- public Pyramid(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Pyramid(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Pyramid";
}
@@ -27,8 +28,8 @@ public void update() {
//int rectWidth = (screenWidth - (arrayController.getLength() - 1)) / arrayController.getLength();
int radius = (int) (Math.min(screenHeight, screenWidth) / 1.7);
- angle -= PApplet.PI / (15 * proc.frameRate);
- proc.lights();
+ angle -= PApplet.PI / (15 * ((PApplet)proc).frameRate);
+ ((PApplet)proc).lights();
for (int i = 0; i < arrayController.getLength(); i++) {
@@ -49,18 +50,18 @@ public void update() {
//proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight, rectWidth, -1 * barHeight); //Classic bar
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
- proc.translate((float) screenWidth / 2, (float) (screenHeight / 2.5), -(int) (Math.min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) (screenHeight / 2.5), -(int) (Math.min(screenHeight, screenWidth) / 10));
- proc.rotateX(PConstants.PI/3);
- proc.rotateZ(angle);
+ ((PApplet)proc).rotateX(PConstants.PI/3);
+ ((PApplet)proc).rotateZ(angle);
- proc.translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
+ ((PApplet)proc).translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
proc.rect(-barHeight/2, -barHeight/2, barHeight, barHeight);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/ScatterPlot.java b/src/main/java/io/github/compilerstuck/Visual/ScatterPlot.java
index 6e13e47..86d7215 100644
--- a/src/main/java/io/github/compilerstuck/Visual/ScatterPlot.java
+++ b/src/main/java/io/github/compilerstuck/Visual/ScatterPlot.java
@@ -1,17 +1,18 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
public class ScatterPlot extends Visualization {
- public ScatterPlot(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public ScatterPlot(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Scatter Plot";
}
@@ -40,9 +41,9 @@ public void update() {
float y = screenHeight - barHeight;
- proc.pushMatrix();
- proc.circle(x, y, 3); //Classic
- proc.popMatrix();
+ ((PApplet)proc).pushMatrix();
+ ((PApplet)proc).circle(x, y, 3); //Classic
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/ScatterPlotLinked.java b/src/main/java/io/github/compilerstuck/Visual/ScatterPlotLinked.java
index e3cabf3..aad318f 100644
--- a/src/main/java/io/github/compilerstuck/Visual/ScatterPlotLinked.java
+++ b/src/main/java/io/github/compilerstuck/Visual/ScatterPlotLinked.java
@@ -1,17 +1,18 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
+import processing.core.PApplet;
public class ScatterPlotLinked extends Visualization {
- public ScatterPlotLinked(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public ScatterPlotLinked(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Scatter Plot Linked";
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Sphere.java b/src/main/java/io/github/compilerstuck/Visual/Sphere.java
index 84e7711..9a3e7c5 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Sphere.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Sphere.java
@@ -1,10 +1,11 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
import java.util.ArrayList;
@@ -18,8 +19,8 @@ public class Sphere extends Visualization {
float squareRoot;
static float aa = 0;
- public Sphere(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public Sphere(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Sphere";
}
@@ -27,7 +28,7 @@ public Sphere(ArrayController arrayController, ColorGradient colorGradient, Soun
public void update() {
super.update();
- proc.lights();
+ ((PApplet)proc).lights();
if (Math.pow(floor(Math.pow(arrayController.getLength(), 1 / 2.)), 2.) != arrayController.getLength()) {
@@ -39,7 +40,7 @@ public void update() {
squareRoot = (int) Math.pow(arrayController.getLength(), 1 / 2.);
- aa -= PApplet.PI / (10 * proc.frameRate);
+ aa -= PApplet.PI / (10 * ((PApplet)proc).frameRate);
float m = 0;
float n = 0;
@@ -124,20 +125,20 @@ public void update() {
if (colors.size() != arrayController.getLength()) return;
Color color = colors.get(i);
- proc.noStroke();
- proc.fill(color.getRGB(), (float) (255.));
+ ((PApplet)proc).noStroke();
+ ((PApplet)proc).fill(color.getRGB(), (float) (255.));
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
//set screen center
- proc.translate((float) screenWidth / 2, (float) screenHeight / 2, -(int) (min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) screenHeight / 2, -(int) (min(screenHeight, screenWidth) / 10));
//set circle position
- proc.translate(xCords.get(i), yCords.get(i), zCords.get(i));
- proc.circle(0, 0, 3);
+ ((PApplet)proc).translate(xCords.get(i), yCords.get(i), zCords.get(i));
+ ((PApplet)proc).circle(0, 0, 3);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/SphereHoops.java b/src/main/java/io/github/compilerstuck/Visual/SphereHoops.java
index b5a5c37..440dc8b 100644
--- a/src/main/java/io/github/compilerstuck/Visual/SphereHoops.java
+++ b/src/main/java/io/github/compilerstuck/Visual/SphereHoops.java
@@ -1,9 +1,10 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import processing.core.PConstants;
import java.lang.Math;
@@ -15,8 +16,8 @@ public class SphereHoops extends Visualization {
float angle = 0;
- public SphereHoops(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public SphereHoops(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Sphere Hoops";
}
@@ -27,8 +28,8 @@ public void update() {
//int rectWidth = (screenWidth - (arrayController.getLength() - 1)) / arrayController.getLength();
int radius = (int) (Math.min(screenHeight, screenWidth) / 1.5);
- angle -= PApplet.PI / (15 * proc.frameRate);
- proc.lights();
+ angle -= PApplet.PI / (15 * ((PApplet)proc).frameRate);
+ ((PApplet)proc).lights();
for (int i = 0; i < arrayController.getLength(); i++) {
@@ -46,23 +47,23 @@ public void update() {
proc.stroke(color.getRGB());
//proc.fill(color.getRGB());
- proc.noFill();
+ ((PApplet)proc).noFill();
//proc.rect(PApplet.map(i, 0, arrayController.getLength(), 0, screenWidth), screenHeight, rectWidth, -1 * barHeight); //Classic bar
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
- proc.translate((float) screenWidth / 2, (float) (screenHeight / 2), -(int) (Math.min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) (screenHeight / 2), -(int) (Math.min(screenHeight, screenWidth) / 10));
- proc.rotateX(PConstants.PI/3);
- //proc.rotateX(angle);
+ ((PApplet)proc).rotateX(PConstants.PI/3);
+ //((PApplet)proc).rotateX(angle);
- proc.translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
+ ((PApplet)proc).translate(0, 0, radius/2 - PApplet.map(i, 0, arrayController.getLength(), 0, radius));
- proc.circle(0, 0, sphere_wi);
+ ((PApplet)proc).circle(0, 0, sphere_wi);
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/SphericDisparityLines.java b/src/main/java/io/github/compilerstuck/Visual/SphericDisparityLines.java
index e965f4b..2f8aba0 100644
--- a/src/main/java/io/github/compilerstuck/Visual/SphericDisparityLines.java
+++ b/src/main/java/io/github/compilerstuck/Visual/SphericDisparityLines.java
@@ -1,10 +1,11 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Control.MainController;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
import java.awt.*;
import java.util.ArrayList;
@@ -18,8 +19,8 @@ public class SphericDisparityLines extends Visualization {
float squareRoot;
static float aa = 0;
- public SphericDisparityLines(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public SphericDisparityLines(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "3D - Spheric Disparity Lines";
}
@@ -27,7 +28,7 @@ public SphericDisparityLines(ArrayController arrayController, ColorGradient colo
public void update() {
super.update();
- proc.lights();
+ ((PApplet)proc).lights();
if (Math.pow(floor(Math.pow(arrayController.getLength(), 1 / 2.)), 2.) != arrayController.getLength()) {
@@ -39,7 +40,7 @@ public void update() {
squareRoot = (int) Math.pow(arrayController.getLength(), 1 / 2.);
- aa -= PApplet.PI / (10 * proc.frameRate);
+ aa -= PApplet.PI / (10 * ((PApplet)proc).frameRate);
float m = 0;
float n = 0;
@@ -125,25 +126,25 @@ public void update() {
if (colors.size() != arrayController.getLength()) return;
Color color = colors.get(i);
- //proc.stroke(color.getRGB());
- proc.stroke(color.getRGB(), 255f);
- proc.fill(color.getRGB(), 255f);
+ //((PApplet)proc).stroke(color.getRGB());
+ ((PApplet)proc).stroke(color.getRGB(), 255f);
+ ((PApplet)proc).fill(color.getRGB(), 255f);
//Max size: 35
- proc.pushMatrix();
+ ((PApplet)proc).pushMatrix();
//set screen center
- proc.translate((float) screenWidth / 2, (float) screenHeight / 2, -(int) (min(screenHeight, screenWidth) / 10));
+ ((PApplet)proc).translate((float) screenWidth / 2, (float) screenHeight / 2, -(int) (min(screenHeight, screenWidth) / 10));
//set circle position
if (i == arrayController.get(i)) {
- proc.translate(xCords.get(i), yCords.get(i), zCords.get(i));
- proc.circle(0, 0, 2);
+ ((PApplet)proc).translate(xCords.get(i), yCords.get(i), zCords.get(i));
+ ((PApplet)proc).circle(0, 0, 2);
} else{
- proc.line(xCords.get(i), yCords.get(i), zCords.get(i), xCords.get(arrayController.get(i)), yCords.get(arrayController.get(i)), zCords.get(arrayController.get(i)));
+ ((PApplet)proc).line(xCords.get(i), yCords.get(i), zCords.get(i), xCords.get(arrayController.get(i)), yCords.get(arrayController.get(i)), zCords.get(arrayController.get(i)));
}
- proc.popMatrix();
+ ((PApplet)proc).popMatrix();
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/SwirlDots.java b/src/main/java/io/github/compilerstuck/Visual/SwirlDots.java
index 0cc47c0..c9f80b1 100644
--- a/src/main/java/io/github/compilerstuck/Visual/SwirlDots.java
+++ b/src/main/java/io/github/compilerstuck/Visual/SwirlDots.java
@@ -1,6 +1,8 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
+import processing.core.PApplet;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
@@ -10,8 +12,8 @@ public class SwirlDots extends Visualization {
int radius;
- public SwirlDots(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
- super(arrayController, colorGradient, sound);
+ public SwirlDots(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
+ super(arrayController, colorGradient, sound, proc);
name = "Swirl Dots";
}
@@ -37,7 +39,7 @@ public void update() {
int x = screenWidth / 2 + (int) (radius * arrayController.get(i) / arrayController.getLength() * Math.sin(phase));
int y = screenHeight / 2 + (int) (radius * arrayController.get(i) / arrayController.getLength() * Math.cos(phase));
- proc.circle(x, y, 5); //Swirl dots
+ ((PApplet)proc).circle(x, y, 5); //Swirl dots
}
}
diff --git a/src/main/java/io/github/compilerstuck/Visual/Visualization.java b/src/main/java/io/github/compilerstuck/Visual/Visualization.java
index 07f4a3b..0f2463a 100644
--- a/src/main/java/io/github/compilerstuck/Visual/Visualization.java
+++ b/src/main/java/io/github/compilerstuck/Visual/Visualization.java
@@ -1,16 +1,15 @@
package io.github.compilerstuck.Visual;
-import io.github.compilerstuck.Control.ArrayController;
-import io.github.compilerstuck.Control.MainController;
+import io.github.compilerstuck.Control.ArrayModel;
+import io.github.compilerstuck.Control.RenderContext;
import io.github.compilerstuck.Sound.Sound;
import io.github.compilerstuck.Visual.Gradient.ColorGradient;
-import processing.core.PApplet;
public abstract class Visualization {
- protected ArrayController arrayController;
+ protected ArrayModel arrayController;
protected ColorGradient colorGradient;
- protected PApplet proc;
+ protected RenderContext proc;
protected int screenWidth;
protected int screenHeight;
protected String name;
@@ -20,13 +19,13 @@ public String getName() {
return name;
}
- public Visualization(ArrayController arrayController, ColorGradient colorGradient, Sound sound) {
+ public Visualization(ArrayModel arrayController, ColorGradient colorGradient, Sound sound, RenderContext proc) {
this.arrayController = arrayController;
this.colorGradient = colorGradient;
- proc = MainController.processing;
+ this.proc = proc;
this.sound = sound;
- screenHeight = proc.height;
- screenWidth = proc.width;
+ screenHeight = proc.getHeight();
+ screenWidth = proc.getWidth();
}
public void updateColorGradient(ColorGradient colorGradient) {
@@ -34,8 +33,8 @@ public void updateColorGradient(ColorGradient colorGradient) {
}
public void update() {
- screenHeight = proc.height;
- screenWidth = proc.width;
+ screenHeight = proc.getHeight();
+ screenWidth = proc.getWidth();
proc.background(15);
diff --git a/src/test/java/io/github/compilerstuck/Control/ArrayModelAndStrategyTest.java b/src/test/java/io/github/compilerstuck/Control/ArrayModelAndStrategyTest.java
new file mode 100644
index 0000000..9d67b9f
--- /dev/null
+++ b/src/test/java/io/github/compilerstuck/Control/ArrayModelAndStrategyTest.java
@@ -0,0 +1,200 @@
+package io.github.compilerstuck.Control;
+
+import io.github.compilerstuck.Control.shuffle.AlmostSortedShuffleStrategy;
+import io.github.compilerstuck.Control.shuffle.RandomShuffleStrategy;
+import io.github.compilerstuck.Control.shuffle.ReverseShuffleStrategy;
+import io.github.compilerstuck.Control.shuffle.SortedShuffleStrategy;
+import io.github.compilerstuck.SortingAlgorithms.SortingAlgorithm;
+import io.github.compilerstuck.Visual.Marker;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Unit tests for ArrayModel, DelayStrategy, and ShuffleStrategy.
+ */
+class ArrayModelAndStrategyTest {
+
+ /** No-op ProcessingContext for testing (avoids any real Processing runtime). */
+ private static final ProcessingContext NO_OP_CTX = ms -> { /* no-op */ };
+
+ private ArrayController controller;
+
+ @BeforeEach
+ void setUp() {
+ SortingAlgorithm.setRun(true);
+ MainController.processing = NO_OP_CTX;
+ controller = new ArrayController(10);
+ }
+
+ // -----------------------------------------------------------------------
+ // ArrayModel – ArrayController basics
+ // -----------------------------------------------------------------------
+
+ @Test
+ @DisplayName("ArrayController initial values are 0..length-1")
+ void initialValuesAreIdentityPermutation() {
+ for (int i = 0; i < controller.getLength(); i++) {
+ assertEquals(i, controller.get(i));
+ }
+ }
+
+ @Test
+ @DisplayName("set() writes value and increments write count")
+ void setWritesValue() {
+ controller.set(3, 99);
+ assertEquals(99, controller.get(3));
+ assertTrue(controller.getWrites() >= 1);
+ }
+
+ @Test
+ @DisplayName("swap() exchanges two elements")
+ void swapExchangesElements() {
+ controller.swap(0, 9);
+ assertEquals(9, controller.get(0));
+ assertEquals(0, controller.get(9));
+ }
+
+ @Test
+ @DisplayName("isSorted() returns true for sorted array")
+ void isSortedReturnsTrueWhenSorted() {
+ assertTrue(controller.isSorted(), "Initial identity permutation should be sorted");
+ }
+
+ @Test
+ @DisplayName("isSorted() returns false after a swap that disorders the array")
+ void isSortedReturnsFalseWhenNotSorted() {
+ controller.swap(0, 9);
+ assertFalse(controller.isSorted());
+ }
+
+ @Test
+ @DisplayName("setMarker() and getMarker() round-trip")
+ void markerRoundTrip() {
+ controller.setMarker(5, Marker.SET);
+ assertEquals(Marker.SET, controller.getMarker(5));
+ }
+
+ @Test
+ @DisplayName("addComparisons() accumulates correctly")
+ void comparisonsAccumulate() {
+ controller.addComparisons(3);
+ controller.addComparisons(7);
+ assertEquals(10, controller.getComparisons());
+ }
+
+ @Test
+ @DisplayName("getArray() returns the backing array view")
+ void getArrayReturnsMutableView() {
+ int[] arr = controller.getArray();
+ assertNotNull(arr);
+ assertEquals(controller.getLength(), arr.length);
+ assertEquals(controller.get(0), arr[0]);
+ }
+
+ @Test
+ @DisplayName("resize() resets state to a fresh identity array")
+ void resizeFreshensState() {
+ controller.swap(0, 9);
+ controller.addComparisons(5);
+ controller.resize(5);
+
+ assertEquals(5, controller.getLength());
+ assertTrue(controller.isSorted());
+ assertEquals(0, controller.getComparisons());
+ }
+
+ // -----------------------------------------------------------------------
+ // DelayStrategy
+ // -----------------------------------------------------------------------
+
+ @Test
+ @DisplayName("DelayStrategy.DEFAULT always delays small arrays")
+ void defaultStrategyDelaysSmallArrays() {
+ // With a 10-element array (< DEFAULT_THRESHOLD), should always delay
+ // at delayFactor = 1.0
+ long fires = 0;
+ for (int i = 0; i < 1000; i++) {
+ if (DelayStrategy.DEFAULT.shouldDelay(10, 1.0)) fires++;
+ }
+ assertEquals(1000, fires, "Should fire every time for tiny array with factor=1.0");
+ }
+
+ @Test
+ @DisplayName("DelayStrategy.DEFAULT respects delayFactor=0 (never delay)")
+ void defaultStrategyRespectsZeroFactor() {
+ long fires = 0;
+ for (int i = 0; i < 1000; i++) {
+ if (DelayStrategy.DEFAULT.shouldDelay(10, 0.0)) fires++;
+ }
+ assertEquals(0, fires, "delayFactor=0 should suppress all delays");
+ }
+
+ @Test
+ @DisplayName("DelayStrategy.DEFAULT fires proportionally for large arrays")
+ void defaultStrategyProportionalForLargeArrays() {
+ // arrayLength = 4000 (> DEFAULT_THRESHOLD=2000), factor=1.0
+ // Expected probability per call ≈ 0.5
+ long fires = 0;
+ int trials = 100_000;
+ for (int i = 0; i < trials; i++) {
+ if (DelayStrategy.DEFAULT.shouldDelay(4000, 1.0)) fires++;
+ }
+ double rate = (double) fires / trials;
+ assertTrue(rate > 0.4 && rate < 0.6,
+ "Expected ~50% fire rate for arrayLength=4000, got " + rate);
+ }
+
+ // -----------------------------------------------------------------------
+ // ShuffleStrategy implementations
+ // -----------------------------------------------------------------------
+
+ @Test
+ @DisplayName("RandomShuffleStrategy produces a permutation (same elements)")
+ void randomShuffleIsPermutation() {
+ new RandomShuffleStrategy().shuffle(controller, NO_OP_CTX);
+ int sum = 0;
+ for (int i = 0; i < controller.getLength(); i++) sum += controller.get(i);
+ assertEquals(45, sum, "Sum of 0..9 should be 45 regardless of order");
+ }
+
+ @Test
+ @DisplayName("ReverseShuffleStrategy reverses the array")
+ void reverseShuffleReversesArray() {
+ new ReverseShuffleStrategy().shuffle(controller, NO_OP_CTX);
+ for (int i = 0; i < controller.getLength(); i++) {
+ assertEquals(controller.getLength() - 1 - i, controller.get(i),
+ "Index " + i + " should be " + (controller.getLength() - 1 - i));
+ }
+ }
+
+ @Test
+ @DisplayName("AlmostSortedShuffleStrategy keeps elements as a permutation")
+ void almostSortedShuffleIsPermutation() {
+ new AlmostSortedShuffleStrategy().shuffle(controller, NO_OP_CTX);
+ int sum = 0;
+ for (int i = 0; i < controller.getLength(); i++) sum += controller.get(i);
+ assertEquals(45, sum);
+ }
+
+ @Test
+ @DisplayName("SortedShuffleStrategy leaves the array sorted")
+ void sortedShuffleLeavesSorted() {
+ // The array starts sorted; SortedShuffle should not swap anything
+ new SortedShuffleStrategy().shuffle(controller, NO_OP_CTX);
+ assertTrue(controller.isSorted());
+ }
+
+ @ParameterizedTest(name = "setShuffleType({0}) wires the correct strategy")
+ @ValueSource(strings = {"RANDOM", "REVERSE", "ALMOST_SORTED", "SORTED"})
+ @DisplayName("setShuffleType wires correct strategy")
+ void setShuffleTypeWiresCorrectStrategy(String typeName) {
+ ShuffleType type = ShuffleType.valueOf(typeName);
+ // Should not throw; just ensure the strategy is set without errors
+ assertDoesNotThrow(() -> controller.setShuffleType(type));
+ }
+}
diff --git a/src/test/java/io/github/compilerstuck/Control/HeadlessVisualizationAndSoundTest.java b/src/test/java/io/github/compilerstuck/Control/HeadlessVisualizationAndSoundTest.java
new file mode 100644
index 0000000..b7555f1
--- /dev/null
+++ b/src/test/java/io/github/compilerstuck/Control/HeadlessVisualizationAndSoundTest.java
@@ -0,0 +1,46 @@
+package io.github.compilerstuck.Control;
+
+import io.github.compilerstuck.Sound.HeadlessSound;
+import io.github.compilerstuck.Visual.Bars;
+import io.github.compilerstuck.Visual.Circle;
+import io.github.compilerstuck.Visual.Gradient.ColorGradient;
+import java.awt.Color;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class HeadlessVisualizationAndSoundTest {
+
+ private ArrayController controller;
+ private HeadlessRenderContext renderCtx;
+ private HeadlessSound sound;
+
+ @BeforeEach
+ void setUp() {
+ MainController.setSize(10);
+ controller = new ArrayController(10);
+ renderCtx = new HeadlessRenderContext(200, 100);
+ sound = new HeadlessSound(controller);
+ }
+
+ @Test
+ @DisplayName("Visualization instances update without throwing exceptions")
+ void visualizationsUpdateHeadlessly() {
+ ColorGradient gradient = new ColorGradient(Color.WHITE, Color.WHITE, Color.BLACK, "test");
+ Bars bars = new Bars(controller, gradient, sound, renderCtx);
+ Circle circle = new Circle(controller, gradient, sound, renderCtx);
+
+ assertDoesNotThrow(bars::update);
+ assertDoesNotThrow(circle::update);
+ }
+
+ @Test
+ @DisplayName("HeadlessSound does nothing when playSound is called")
+ void headlessSoundNoOp() {
+ sound.playSound(5);
+ // no exception and nothing to verify - simply ensure method exists
+ assertTrue(true);
+ }
+}
diff --git a/src/test/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithmsTest.java b/src/test/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithmsTest.java
index 4bce7c4..1684d64 100644
--- a/src/test/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithmsTest.java
+++ b/src/test/java/io/github/compilerstuck/SortingAlgorithms/SortingAlgorithmsTest.java
@@ -1,5 +1,6 @@
package io.github.compilerstuck.SortingAlgorithms;
+import io.github.compilerstuck.Control.ArrayModel;
import io.github.compilerstuck.Control.ArrayController;
import io.github.compilerstuck.Control.MainController;
import org.junit.jupiter.api.BeforeAll;
@@ -24,7 +25,7 @@ class SortingAlgorithmsTest {
* Most of the sorting code only ever calls {@code delay(int)}, so we provide a
* no-op implementation to avoid starting a real graphics context during tests.
*/
- static class DummyProcessing extends PApplet {
+ static class DummyProcessing extends PApplet implements io.github.compilerstuck.Control.ProcessingContext {
@Override
public void delay(int ms) {
// do nothing, keep tests fast
@@ -113,7 +114,7 @@ void algorithmShouldSort(Class algoClass, int size)
for (int i = 0; i < size; i++) {
controller.set(i, values[i]);
}
- SortingAlgorithm algorithm = algoClass.getConstructor(ArrayController.class)
+ SortingAlgorithm algorithm = algoClass.getConstructor(ArrayModel.class)
.newInstance(controller);
algorithm.setDelay(false);
algorithm.sort();