Fixed #23 See comments for desc

dlarocque · dlarocque · commit d14ad1dfe5cf · 2020-08-20T11:58:23.000-05:00
diff --git a/src/com/example/algorithmvisualizer/AlgVisualizer.java b/src/com/example/algorithmvisualizer/AlgVisualizer.java
@@ -86,7 +86,8 @@ public void initializeVars() {
 
 		// Initialize objects that will display and sort the array
 
-		arrDisplay = new ArrDisplay(this, arr);
+		arrDisplay = new ArrDisplay(this);
+		arrDisplay.setArr(arr);
 		arrDisplay.setPreferredSize(new Dimension(CONTENT_WIDTH, ARR_DISPLAY_HEIGHT));
 
 		arrSort = new ArrSorting(this, this.arr, this.arrDisplay);
@@ -217,7 +218,7 @@ public void actionPerformed(ActionEvent event) {
 		} else if (event.getSource() == performanceButton) {
 			int numSwaps = arrDisplay.getSwappedIndexes().size();
 			long visualizationTime = endTime - startTime; // net time
-			long sortingTime = visualizationTime - (60 * numSwaps + 1); // - 60 seconds of sleep time between each swap
+			long sortingTime = visualizationTime - (60 * numSwaps + 1); // - NEED TO FIX
 			String statsMessage = String.format(
 					"Index Comparisons : %d  Index Swaps : %d  Visualization Time : %dms  Sorting Time : %dms",
 					indexComparisons, numSwaps, visualizationTime, sortingTime);
@@ -238,7 +239,7 @@ public void reset() {
 		setStopSort(true);
 		arr = shuffleArr(arr);
 		arrDisplay.clearSwappedIndexes();
-		arrDisplay.setFramesPainted(0);
+		arrDisplay.setNumChunk(0);
 		arrDisplay.setComplete(false);
 		arrDisplay.setArr(arr);
 		indexComparisons = 0;
diff --git a/src/com/example/algorithmvisualizer/ArrDisplay.java b/src/com/example/algorithmvisualizer/ArrDisplay.java
@@ -22,15 +22,14 @@ public class ArrDisplay extends JComponent {
 	private static final long serialVersionUID = 1L;
 	private int swappedIndex1;
 	private int swappedIndex2;
-	private int framesPainted; // amount of frames painted since the array was shuffled
+	private int numChunk; // amount of frames painted since the array was shuffled
 	private boolean isComplete; // if the array is sorted
 	private ArrayList<Integer[]> swappedIndexes;
 	private Integer[] arr;
 	private AlgVisualizer algVisualizer;
 
-	public ArrDisplay(AlgVisualizer algVisualizer, Integer[] arr) {
+	public ArrDisplay(AlgVisualizer algVisualizer) {
 		this.algVisualizer = algVisualizer;
-		this.arr = arr;
 		swappedIndexes = new ArrayList<Integer[]>();
 	}
 
@@ -39,12 +38,15 @@ public ArrDisplay(AlgVisualizer algVisualizer, Integer[] arr) {
 	 * visualization of the array in bar graph form. This method is called through
 	 * the use of the repaint() method that is called in the SwingWorkers publish()
 	 * method. We use loops to iterate through the array and draw every index,
-	 * filling the arrPanel. A list of arrays contains pairs of swapped indexes that
-	 * are drawn in red & blue. We iterate through this list every frame by keeping
-	 * track of the amount of frames drawn. ISSUE : If the number of framesPainted
-	 * is out of sync with the List of pairs of swappedIndexes, the coloured bars
-	 * will be out of sync with the actual indexes that are being swapped, giving
-	 * the effect of a very noticeable delay.
+	 * filling the arrPanel.
+	 * 
+	 * Since this method can take some time to execute, it may only be able to draw
+	 * a fraction of the total frames at lower delay times.
+	 * 
+	 * There is a list of swappedIndexes that contains each pair of indexes that
+	 * were swapped during sorting. Since we always draw the most recent chunk,
+	 * numChunks will always represent the number of the array clone we're drawing,
+	 * so using that to get the correct index in swappedIndexes will work.
 	 */
 	@Override
 	public void paintComponent(Graphics g) {
@@ -59,8 +61,8 @@ public void paintComponent(Graphics g) {
 			swappedIndex1 = -1;
 			swappedIndex2 = -1;
 		} else if (!algVisualizer.stopSort()) {
-			swappedIndex1 = swappedIndexes.get(framesPainted)[0];
-			swappedIndex2 = swappedIndexes.get(framesPainted++)[1];
+			swappedIndex1 = swappedIndexes.get(numChunk - 1)[0];
+			swappedIndex2 = swappedIndexes.get(numChunk - 1)[1];
 		}
 
 		// Iterate through the array and drawn every index
@@ -102,12 +104,12 @@ public void clearSwappedIndexes() {
 		swappedIndexes = new ArrayList<Integer[]>();
 	}
 
-	public void setFramesPainted(int framesPainted) {
-		this.framesPainted = framesPainted;
+	public void setNumChunk(int numChunk) {
+		this.numChunk = numChunk;
 	}
 
-	public int getFramesPainted() {
-		return framesPainted;
+	public int getNumChunk() {
+		return numChunk;
 	}
 
 	public boolean isComplete() {
diff --git a/src/com/example/algorithmvisualizer/ArrSorting.java b/src/com/example/algorithmvisualizer/ArrSorting.java
@@ -18,11 +18,12 @@
 
 public class ArrSorting extends SwingWorker<Void, Integer[]> {
 
-	private final int SLEEP_TIME = 60; // sleep time between frames drawn (ms)
+	private Integer delay = 10;
 	private int n;
 	private Integer[] arr;
 	private AlgVisualizer algVisualizer;
 	private ArrDisplay arrDisplay;
+	private int numChunk;
 
 	public ArrSorting(AlgVisualizer algVisualizer, Integer[] arr, ArrDisplay arrDisplay) {
 		this.algVisualizer = algVisualizer;
@@ -37,7 +38,7 @@ public ArrSorting(AlgVisualizer algVisualizer, Integer[] arr, ArrDisplay arrDisp
 	 * determine what buttons was clicked, helping determine what action to do next.
 	 * If a reset was done, redraw the new shuffled array, and reset this object so
 	 * that it is able to sort the next time execute() is called. If a sorting
-	 * algorithm was clicked, simply perform that sorting algortihm. Make sure to
+	 * algorithm was clicked, simply perform that sorting algorithm. Make sure to
 	 * set the start and end times for the performance window at the end of sorting.
 	 */
 	@Override
@@ -65,29 +66,42 @@ protected Void doInBackground() throws Exception {
 	}
 
 	/*
-	 * This method is called by the publish(arr.clone()) method in the sorting
-	 * algorithms. It takes in a chunk of the array that was sent as a parameter,
-	 * and repaints it using the overridden paintComponent(). ISSUE : If an array
-	 * clone is sent to this method as a chunk before the repaint() method is
-	 * complete, the visualization can come out of sync. See issue #23 at
-	 * https://github.com/dlarocque/AlgorithmVisualizer/issues/23
+	 * This method accepts a clone of the array that was sent to it as a parameter
+	 * from the sorting algorithms. If this method isn't finished executing by the
+	 * time that another publish(Arr.clone()) is made, it will send in the array
+	 * clone at the end of the list of chunks.
+	 * 
+	 * Since the repaint() method can not keep up with the amount of chunks sent in
+	 * from the sorting algorithms when there is very low delay time (Repaint time
+	 * depends on the system), it will only draw a fraction of the array clones sent
+	 * to it.
+	 * 
+	 * To make sure that the colored bars representing the swapped indexes are in
+	 * sync with the array being painted, we track the amount of chunks sent, and
+	 * send it to arrDisplay, so that whenever repaint() has the opportunity to
+	 * execute, the chunk number of the array clone that is being drawn will be
+	 * represented by numChunk, which will be used to get the swappedIndexes from
+	 * the list. ( numChunk are swappedIndexes.size() are always equal. )
 	 */
 	@Override
 	protected void process(List<Integer[]> chunks) {
-		if (chunks.size() > 1) {
-			// If chunks > 1, Red bars will be out of sync
-			System.out.println("OVERLOAD" + chunks.size());
+		while (chunks.size() > 0) {
+			// Paint each cloned array and update number of chunks
+			numChunk++;
+			arrDisplay.setNumChunk(this.numChunk);
+			arrDisplay.setArr(chunks.get(0));
+			arrDisplay.repaint();
+			chunks.remove(0);
 		}
-		arrDisplay.repaint();
 	}
 
 	/*
-	 * Amount of time this thread will sleep for, waiting for the repaint() method
-	 * to draw the previous clone of the array.
+	 * The amount of time this thread waits after sending a chunk to be drawn in the
+	 * Event Dispatch Thread
 	 */
 	private void sleep() {
 		try {
-			Thread.sleep(SLEEP_TIME);
+			Thread.sleep(delay);
 		} catch (InterruptedException e) {
 			e.printStackTrace();
 		}
@@ -116,17 +130,18 @@ private void bubbleSort() {
 						// Add the pair of indexes that were swapped to the list.
 						arrDisplay.addSwappedIndexes(j, j + 1);
 						// Repaint the new array.
-						publish();
+						publish(arr.clone());
 						sleep();
 					}
 				}
 			}
 		}
-		// If sorting hasn't been stopped, set end time, complete and draw one more time.
+		// If sorting hasn't been stopped, set end time, complete and draw one more
+		// time.
 		if (!algVisualizer.stopSort()) {
 			algVisualizer.setEndTime(System.currentTimeMillis());
 			arrDisplay.setComplete(true);
-			publish();
+			publish(arr.clone());
 			sleep();
 		}
 	}
@@ -154,13 +169,13 @@ private void selectionSort() {
 			// Add a pair of swapped indexes
 			arrDisplay.addSwappedIndexes(min_idx, i);
 			// Repaint the new array.
-			publish();
+			publish(arr.clone());
 			sleep();
 		}
 		// If sorting hasn't been stopped, set complete and draw one more time.
 		if (!algVisualizer.stopSort()) {
 			arrDisplay.setComplete(true);
-			publish();
+			publish(arr.clone());
 			sleep();
 		}
 	}
@@ -178,7 +193,7 @@ private void insertionSort() {
 
 			while (j >= 0 && arr[j] > key) { // compare arr[j] and arr[i]
 				if (algVisualizer.stopSort()) {
-					publish();
+					publish(arr.clone());
 					sleep();
 					break;
 				}
@@ -190,7 +205,7 @@ private void insertionSort() {
 				// Add a pair of swapped indexes
 				arrDisplay.addSwappedIndexes(j, j + 1);
 				// Repaint the array
-				publish();
+				publish(arr.clone());
 				sleep();
 			}
 			// Add a pair of swapped indexes
@@ -201,7 +216,7 @@ private void insertionSort() {
 		// If sorting hasn't been stopped, set complete and draw one more time.
 		if (!algVisualizer.stopSort()) {
 			arrDisplay.setComplete(true);
-			publish();
+			publish(arr.clone());
 			sleep();
 		}
 	}
@@ -222,7 +237,7 @@ private void mergeSort(int l, int r) {
 			// If sorting is done and a reset has not been done, repaint one more time
 			if (isSorted() && !algVisualizer.stopSort()) {
 				arrDisplay.setComplete(true);
-				publish();
+				publish(arr.clone());
 				sleep();
 
 			}
@@ -268,15 +283,15 @@ private void merge(int l, int m, int r) {
 					// Add a pair of swapped indexes
 					arrDisplay.addSwappedIndexes(k, k + i);
 					// Repaint the array
-					publish();
+					publish(arr.clone());
 					sleep();
 				} else {
 					arr[k] = R[j];
 					j++;
 					// Add a pair of swapped indexes
 					arrDisplay.addSwappedIndexes(k, k + j);
 					// Repaint the arrays
-					publish();
+					publish(arr.clone());
 					sleep();
 				}
 				k++;
@@ -292,7 +307,7 @@ private void merge(int l, int m, int r) {
 				// Add a pair of swapped indexes
 				arrDisplay.addSwappedIndexes(k, k + i);
 				// Repaint the array
-				publish();
+				publish(arr.clone());
 				sleep();
 				i++;
 				k++;
@@ -307,7 +322,7 @@ private void merge(int l, int m, int r) {
 				arr[k] = R[j];
 				// Add a pair of swapped indexes
 				arrDisplay.addSwappedIndexes(k, k + j);
-				publish();
+				publish(arr.clone());
 				sleep();
 				j++;
 				k++;
@@ -316,7 +331,7 @@ private void merge(int l, int m, int r) {
 	}
 
 	private void quickSort(int low, int high) {
-		if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) {  // Needed because of recursion
+		if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of recursion
 			if (low < high) {
 				// pi is partitioning index, arr[pi] is now at right place
 				int pi = partition(low, high);
@@ -330,7 +345,7 @@ private void quickSort(int low, int high) {
 			// the array is sorted besides this
 			if (isSorted() && !algVisualizer.stopSort()) {
 				arrDisplay.setComplete(true);
-				publish();
+				publish(arr.clone());
 				sleep();
 			}
 		}
@@ -342,7 +357,8 @@ private int partition(int low, int high) {
 			int i = (low - 1); // index of smaller element
 
 			for (int j = low; j < high; j++) {
-				if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of recursion
+				if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of
+																									// recursion
 					// Add a comparison
 					algVisualizer.setIndexComparisons(algVisualizer.getIndexComparisons() + 1);
 
@@ -363,7 +379,8 @@ private int partition(int low, int high) {
 					}
 				}
 			}
-			if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of recursion
+			if (algVisualizer.getSort().equals("Quick Sort") && !algVisualizer.stopSort()) { // Needed because of
+																								// recursion
 				// swap arr[i+1] and arr[high] (or pivot)
 				int temp = arr[i + 1];
 				arr[i + 1] = arr[high];
