perf: optimize plotting pipeline and reduce allocations

- Eliminated cartesianToJavaUnscaled() and fused transform logic into cartesianToJava()
  → avoids extra method call and Point2D.Double allocation
- Mutated input point in-place to reduce heap churn during plotting
- Removed getPoint2D() and getPoint3D() helpers to inline projection and transform
- Hoisted setProjection(), setStroke(), and FG color setup outside the main loop
  → avoids redundant calls per data row
- Cached fgColor and fgColor2 for reuse in LINES_POINTS mode
- Added parallelMaxMin() in Stats to compute all column extrema in one pass
  → avoids repeated getColumn() calls and redundant loops
- PlotData now caches max/min results and invalidates them on setData()
- Updated getMin()/getMax() to use cached extrema
- Updated describeColumn() to use getMin()/getMax() for consistency and performance

Result: reduced per-frame overhead, fewer allocations, and improved responsiveness during zoom/rotate.

Profiled using VisualVM

Author: babaissarkar

src/main/java/com/babai/ssplot/math/plot/Canvas.java

@@ -437,17 +437,14 @@ public void shift(int i, int j) {
 
 	// NOTE: these mutate argument (passed point) to avoid allocating new Point2D.Double
 
-	/* Transforms from Cartesian space to Java Graphics space. */
-	/* Takes care of scaling and translation */
+	/**
+	 * Transforms from Cartesian space to Java Graphics space.
+	 * Takes care of scaling and translation
+	 */
 	public Point2D.Double cartesianToJava(Point2D.Double p) {
-		p.x = scaleFactor*(p.x-zc.x) + zc.x;
-		p.y = scaleFactor*(p.y-zc.y) + zc.y;
-		return cartesianToJavaUnscaled(p);
-	}
-
-	private Point2D.Double cartesianToJavaUnscaled(Point2D.Double p) {
-		p.x = p.x + dx + moveX;
-		p.y = H - (p.y + dy + moveY);
+		double sF = 1 - scaleFactor;
+		p.x = scaleFactor*p.x + sF*zc.x + dx + moveX;
+		p.y = H - (scaleFactor*p.y + sF*zc.y + dy + moveY);
 		return p;
 	}
 

src/main/java/com/babai/ssplot/math/plot/PlotData.java

@@ -38,7 +38,7 @@
  * including the data, the plot properties and the system
  * of equations.
  */
-public class PlotData implements Cloneable {	
+public class PlotData implements Cloneable {
 	public enum PlotType {
 		LINES("2D Lines"),
 		POINTS("2D Points"),
@@ -86,6 +86,9 @@ public enum PointType { SQUARE, CIRCLE };
 
 	private Color fgColor, fgColor2;
 	private String title;
+	
+	private boolean maxMinComputed = false;
+	private double[][] maxMin;
 
 	public PlotData(double[][] extData) {
 		data = extData;
@@ -129,7 +132,7 @@ public Optional<String> getAxisLabel(int i) {
 
 	// ------------- DATA METHODS -----------------
 	public double[][] getData() { return data; }
-	public void setData(double[][] data) { this.data = data; }
+	public void setData(double[][] data) { maxMinComputed = false; this.data = data; }
 	public int getRowCount() { return data.length; }
 
 	// NOTE: Right now, number of columns of data == number of axes. If that changes
@@ -197,12 +200,13 @@ public void setDataCols(int... dataCols) {
 
 	public HashMap<Integer, Integer> getDataColMapping() { return this.dataColumnMapping; }
 
+	// NOTE expensive method
 	public double[] getColumn(int i) {
 		double[] colData = new double[getRowCount()];
+		if (i >= getColumnCount()) return colData;
+		
 		for (int rowIdx = 0; rowIdx < colData.length; rowIdx++) {
-			if (i < getColumnCount()) {
-				colData[rowIdx] = this.data[rowIdx][i]; 
-			}
+			colData[rowIdx] = this.data[rowIdx][i]; 
 		}
 		return colData;
 	}
@@ -211,13 +215,25 @@ public double[] getColumn(int i) {
 	 * @param dataCol     index of a column
 	 * @return            maximum value among all data in the given column
 	 */
-	public double getMax(int dataCol) { return Stats.max(getColumn(dataCol)); }
+	public double getMax(int dataCol) {
+		if (!maxMinComputed) {
+			this.maxMin = Stats.parallelMaxMin(data);
+			maxMinComputed = true;
+		}
+		return this.maxMin[0][dataCol];
+	}
 
 	/**
 	 * @param dataCol     index of a column
 	 * @return            min value among all data in the given column
 	 */
-	public double getMin(int dataCol) { return Stats.min(getColumn(dataCol)); }
+	public double getMin(int dataCol) {
+		if (!maxMinComputed) {
+			this.maxMin = Stats.parallelMaxMin(data);
+			maxMinComputed = true;
+		}
+		return this.maxMin[1][dataCol];
+	}
 
 
 	// ------------------ NODE METHODS -------------------
@@ -251,9 +267,9 @@ private String formatStats(String colName, int i) {
 					Q1=%.4f, Median=%.4f, Q3=%.4f
 				""",
 				colName,
-				colData.length,
-				Stats.min(colData),
-				Stats.max(colData),
+				getRowCount(),
+				getMin(i),
+				getMax(i),
 				Stats.mean(colData),
 				Stats.variance(colData),
 				Stats.stdDev(colData),

src/main/java/com/babai/ssplot/math/plot/Plotter.java

@@ -80,9 +80,17 @@ private void plotData(PlotData pdata, int lastIndex) {
 
 		canv.setFGColor(pdata.getFgColor());
 		canv.setAxes3d(pdata.getColumnCount() == 3);
+		canv.setProjection(p);
+		canv.setStroke(pdata.ptX);
+		Color fgColor = canv.getFGColor();
+		Color fgColor2 = pdata.getFgColor2();
 
+		double[] row;
+		
+		// NOTE this is a huge loop, be careful of even small method calls,
+		// can stockpile easily.
 		for (int i = 0; i < lastIndex; i++) {
-			var row = dataset[i];
+			row = dataset[i];
 
 			switch(pdata.getPlotType()) {
 				case VFIELD -> {
@@ -91,28 +99,25 @@ private void plotData(PlotData pdata, int lastIndex) {
 					if (row.length >= 4) {
 						p1 = canv.cartesianToJava(new Point2D.Double(row[0], row[1]));
 						p2 = canv.cartesianToJava(new Point2D.Double(row[2], row[3]));
-	
-						canv.drawVector(p1, p2, pdata.getFgColor2());
+						canv.drawVector(p1, p2, fgColor2);
 					} else {
 						System.err.println("Bad vector field data!");
 					}
 				}
 
 				case POINTS3 -> {
 					if (row.length >= 3) {
-						canv.setProjection(p);
-						canv.drawPoint(getPoint3D(row, dataCols, p, 0, 1, 2), PlotData.PointType.SQUARE, pdata.ptX, pdata.ptY);
+						p1 = canv.cartesianToJava(p.project(row[dataCols[0]], row[dataCols[1]], row[dataCols[2]]));
+						canv.drawPoint(p1, PlotData.PointType.SQUARE, pdata.ptX, pdata.ptY);
 					} else {
 						System.err.println("Data is not three dimensional!");
 					}
 				}
 
 				case LINES3 -> {
 					if (row.length >= 3) {
-						p2 = getPoint3D(row, dataCols, p, 0, 1, 2);
+						p2 = canv.cartesianToJava(p.project(row[dataCols[0]], row[dataCols[1]], row[dataCols[2]]));
 						if (p1 != null) {
-							canv.setProjection(p);
-							canv.setStroke(pdata.ptX);
 							canv.drawLine(p1, p2);
 						}
 						p1 = p2;
@@ -122,31 +127,26 @@ private void plotData(PlotData pdata, int lastIndex) {
 				}
 
 				case POINTS, LINES, LINES_POINTS -> {
-					p2 = getPoint2D(row, dataCols, 0, 1);
+					p2 = canv.cartesianToJava(new Point2D.Double(row[dataCols[0]], row[dataCols[1]]));
 
 					if (p1 != null) {
 						switch(pdata.getPlotType()) {
-							case LINES -> {
-								canv.setStroke(pdata.ptX);
-								canv.drawLine(p1, p2);
-							}
+							case LINES -> canv.drawLine(p1, p2);
 
 							case POINTS -> canv.drawPoint(p1, PlotData.PointType.SQUARE, pdata.ptX, pdata.ptY);
 
 							case LINES_POINTS -> {
-								Color c = canv.getFGColor();
 								Point2D.Double pback = new Point2D.Double(
 									p1.getX() - (pdata.ptX+4)/2,
 									p1.getY() - (pdata.ptY+4)/2);
 								// The line is drawn with plot FGcolor 1
 								// the points on the top is drawn with plot FGcolor 2
 								// FIXME generalization needed
-								canv.setStroke(pdata.ptX);
 								canv.drawLine(p1, p2);
 
-								canv.setFGColor(pdata.getFgColor2());
+								canv.setFGColor(fgColor2);
 								canv.drawPoint(pback, PlotData.PointType.CIRCLE, pdata.ptX+4, pdata.ptY+4);
-								canv.setFGColor(c);
+								canv.setFGColor(fgColor);
 							}
 
 							default -> {}
@@ -171,16 +171,6 @@ private void plotOthers(PlotData pdata) {
 		}
 	}
 
-	private Point2D.Double getPoint3D(double[] row, int[] dataCols, Project2D projector,
-			int i, int j, int k)
-	{
-		return canv.cartesianToJava(projector.project(row[dataCols[i]], row[dataCols[j]], row[dataCols[k]]));
-	}
-
-	private Point2D.Double getPoint2D(double[] row, int[] dataCols, int c1, int c2) {
-		return canv.cartesianToJava(new Point2D.Double(row[dataCols[c1]], row[dataCols[c2]]));
-	}
-
 	public BufferedImage getImage() {
 		return canv.getImage();
 	}

src/main/java/com/babai/ssplot/math/plot/Stats.java

@@ -69,4 +69,19 @@ public static double min(double[] column) {
 		}
 		return min;
 	}
+	
+	/** Calculate max + mins for all columns at once to avoid multiple loops */
+	public static double[][] parallelMaxMin(double[][] data) {
+		int cols = data[0].length;
+		double[] max = Arrays.copyOf(data[0], cols);
+		double[] min = Arrays.copyOf(data[0], cols);
+		
+		for (int i = 1; i < data.length; i++) {
+			for (int j = 0; j < data[0].length; j++) {
+				max[j] = Math.max(data[i][j], max[j]);
+				min[j] = Math.min(data[i][j], min[j]);
+			}
+		}
+		return new double[][] { max, min };
+	}
 }