fix jaggies on horizontal/vertical linear gradient (#17)

Author: micycle1

src/main/micycle/peasygradients/PeasyGradients.java

@@ -343,7 +343,7 @@ public void linearGradient(Gradient gradient, PVector centerPoint, double angle)
 
 		double modAngle = angle % TWO_PI;
 
-		if (modAngle > PConstants.HALF_PI && modAngle <= PConstants.HALF_PI * 3) {
+		if (modAngle > HALF_PI && modAngle <= HALF_PI * 3) {
 			linearGradient(gradient, o[0], o[1]);
 		} else {
 			linearGradient(gradient, o[1], o[0]);
@@ -543,11 +543,11 @@ public void polygonGradient(Gradient gradient, PVector centerPoint, double angle
 		 * of the polygon to the midpoint of each side (which are closer than vertices)
 		 */
 		final double MIN_LENGTH_RATIO = FastMath.tan(HALF_PI - (Math.PI / sides)); // used for hexagon gradient (== tan(60)) tan(SIDES)
-		final double SEGMENT_ANGLE = (2 * Math.PI) / sides; // max angle of polygon segment in radians
+		final double SEGMENT_ANGLE = TWO_PI / sides; // max angle of polygon segment in radians
 
 		angle %= SEGMENT_ANGLE; // mod angle to minimise difference between theta and SEGMENT_ANGLE in loop
 
-		final double denominator = MIN_LENGTH_RATIO / ((Math.max(renderHeight, renderWidth)) * (0.01 * zoom * FastMath.pow(sides, 2.4)));
+		final double denominator = MIN_LENGTH_RATIO / ((Math.max(renderHeight, renderWidth)) * (0.0125 * zoom * FastMath.pow(sides, 2.4)));
 
 		int LUT_SIZE = (int) Functions.max(2000, renderWidth * 20f, renderHeight * 20f); // suitable value?
 		final int HALF_LUT_SIZE = (int) (LUT_SIZE / TWO_PI);
@@ -1061,7 +1061,7 @@ public Boolean call() {
 				rise = renderMidpointY - y;
 				for (int x = 0; x < gradientPG.width; x++) { // FULL WIDTH
 					run = renderMidpointX - x;
-					t = Functions.fastAtan2b(rise, run) + PConstants.PI - angle; // + PI to align bump with angle
+					t = Functions.fastAtan2b(rise, run) + Math.PI - angle; // + PI to align bump with angle
 					t *= INV_TWO_PI; // normalise
 					t -= Math.floor(t); // modulo
 

src/main/micycle/peasygradients/utilities/Functions.java

@@ -24,8 +24,9 @@ public final class Functions {
 	private static final FastLog fastLog = new DFastLog(10); // Used in veryFastPow(), 10 => 2KB table
 
 	private static final float PI = (float) Math.PI;
-	private static final float TWO_PI = (float) (2 * Math.PI);
-	private static final float HALF_PI = (float) (0.5f * Math.PI);
+	private static final float TWO_PI_F = (float) (2 * Math.PI);
+	private static final double TWO_PI = 2 * Math.PI;
+	private static final float HALF_PI_F = (float) (0.5f * Math.PI);
 	private static final float QRTR_PI_F = (float) (0.25f * Math.PI);
 	private static final float THREE_QRTR_PI_F = (float) (0.75f * Math.PI);
 	private static final double QRTR_PI = (0.25 * Math.PI);
@@ -73,17 +74,17 @@ public static float linearProject(float originX, float originY, float destX, flo
 	public static float angleBetween(PVector tail, PVector head) {
 		float a = fastAtan2b(tail.y - head.y, tail.x - head.x);
 		if (a < 0) {
-			a += TWO_PI;
+			a += TWO_PI_F;
 		}
 		return a;
 	}
 
-	public static double angleBetween(PVector head, float tailX, float tailY) {
+	public static double angleBetween(PVector head, double tailX, double tailY) {
 		double a = fastAtan2b(tailY - head.y, tailX - head.x);
 		if (a < 0) {
 			a += TWO_PI;
 		}
-		return a;
+		return snapAngleToQuarterPi(a);
 	}
 
 	/**
@@ -146,7 +147,7 @@ public static float random(float min, float max) {
 	public static float randomFloat() {
 		return random.nextFloat();
 	}
-	
+
 	/**
 	 * Returns a pseudorandom, uniformly distributed double value between 0.0
 	 * (inclusive) and 1.0 (exclusive).
@@ -349,16 +350,16 @@ public static double fastAtan2a(double y, double x) {
 				final double z = x / y;
 				if (y > 0.0) {
 					// atan2(y,x) = PI/2 - atan(x/y) if |y/x| > 1, y > 0
-					return -fastAtan(z) + HALF_PI;
+					return -fastAtan(z) + HALF_PI_F;
 				} else {
 					// atan2(y,x) = -PI/2 - atan(x/y) if |y/x| > 1, y < 0
-					return -fastAtan(z) - HALF_PI;
+					return -fastAtan(z) - HALF_PI_F;
 				}
 			}
 		} else if (y > 0.0f) { // x = 0, y > 0
-			return HALF_PI;
+			return HALF_PI_F;
 		} else if (y < 0.0f) { // x = 0, y < 0
-			return -HALF_PI;
+			return -HALF_PI_F;
 		}
 		return 0.0f; // x,y = 0. Could return NaN instead.
 	}
@@ -390,24 +391,24 @@ public static float fastAtan2b(final float y, final float x) {
 			return (angle);
 		}
 	}
-	
+
 	public static double fastAtan2b(final double y, final double x) {
-	    double r, angle;
-	    final double abs_y = Math.abs(y) + 1e-10; // kludge to prevent 0/0 condition
-
-	    if (x < 0.0) {
-	        r = (x + abs_y) / (abs_y - x);
-	        angle = THREE_QRTR_PI;
-	    } else {
-	        r = (x - abs_y) / (x + abs_y);
-	        angle = QRTR_PI;
-	    }
-	    angle += (0.1963 * r * r - 0.9817) * r;
-	    if (y < 0.0) {
-	        return (-angle);
-	    } else {
-	        return (angle);
-	    }
+		double r, angle;
+		final double abs_y = Math.abs(y) + 1e-10; // kludge to prevent 0/0 condition
+
+		if (x < 0.0) {
+			r = (x + abs_y) / (abs_y - x);
+			angle = THREE_QRTR_PI;
+		} else {
+			r = (x - abs_y) / (x + abs_y);
+			angle = QRTR_PI;
+		}
+		angle += (0.1963 * r * r - 0.9817) * r;
+		if (y < 0.0) {
+			return (-angle);
+		} else {
+			return (angle);
+		}
 	}
 
 	/**
@@ -451,8 +452,8 @@ public static float fastAtan2c(float y, float x) {
 	 * @return the interpolated angle in the range [0, 2PI]
 	 */
 	public static float lerpAngle(float fromRadians, float toRadians, float progress) {
-		float delta = ((toRadians - fromRadians + TWO_PI + PI) % TWO_PI) - PI;
-		return (fromRadians + delta * progress + TWO_PI) % TWO_PI;
+		float delta = ((toRadians - fromRadians + TWO_PI_F + PI) % TWO_PI_F) - PI;
+		return (fromRadians + delta * progress + TWO_PI_F) % TWO_PI_F;
 	}
 
 	/**
@@ -472,14 +473,15 @@ public static float lerpAngle(float fromRadians, float toRadians, float progress
 	 * @return PVector[2] containing the two points of intersection
 	 * @see #lineRectIntersection(float, float, PVector, float)
 	 */
-	public static PVector[] lineRectIntersection(PVector[] rect, PVector point, float angle) {
+	public static PVector[] lineRectIntersection(PVector[] rect, PVector point, double angle) {
 
 		PVector[] output = new PVector[2];
 		output[0] = new PVector();
 		output[1] = new PVector();
 
-		final float tanA = (float) Math.tan(TWO_PI - angle); // 'TWO_PI - ___' for clockwise orientation
-		
+		angle = snapAngleToQuarterPi(angle); // handle float versions of PI properly
+		final double tanA = Math.tan(TWO_PI - angle); // 'TWO_PI - ___' for clockwise orientation
+
 		// Avoid division by zero
 		if (tanA == 0) {
 			output[0].x = rect[3].x;
@@ -529,17 +531,40 @@ public static PVector[] lineRectIntersection(float rectWidth, float rectHeight,
 		rect[3] = new PVector(rectWidth, 0);
 		return lineRectIntersection(rect, point, angle);
 	}
-	
+
 	/**
-	 * Double-argument version of {@link #lineRectIntersection(float, float, PVector, float)}.
+	 * Double-argument version of
+	 * {@link #lineRectIntersection(float, float, PVector, float)}.
 	 */
 	public static PVector[] lineRectIntersection(double rectWidth, double rectHeight, PVector point, double angle) {
-	    final PVector[] rect = new PVector[4];
-	    rect[0] = new PVector(0, 0);
-	    rect[1] = new PVector(0, (float) rectHeight);
-	    rect[2] = new PVector((float) rectWidth, (float) rectHeight);
-	    rect[3] = new PVector((float) rectWidth, 0);
-	    return lineRectIntersection(rect, point, (float) angle);
+		final PVector[] rect = new PVector[4];
+		rect[0] = new PVector(0, 0);
+		rect[1] = new PVector(0, (float) rectHeight);
+		rect[2] = new PVector((float) rectWidth, (float) rectHeight);
+		rect[3] = new PVector((float) rectWidth, 0);
+		return lineRectIntersection(rect, point, angle);
+	}
+
+	/**
+	 * Corrects the angle to be a multiple of π/4 if it is very close to that
+	 * multiple, addressing floating-point precision issues with common angles like
+	 * π and π/2.
+	 * <p>
+	 * This method is especially useful when exact values are crucial for functions
+	 * like sin, cos, or tan, which may not behave as expected due to floating-point
+	 * inaccuracies (such as <code>float</code> version of π).
+	 *
+	 * @param angle the original angle in radians.
+	 * @return the adjusted angle, snapped to the nearest multiple of π/4 if within
+	 *         a small threshold.
+	 */
+	public static double snapAngleToQuarterPi(double angle) {
+		angle = angle % TWO_PI;
+		double halfPiMultiple = Math.round(angle / QRTR_PI) * QRTR_PI;
+		if (Math.abs(angle - halfPiMultiple) < 0.00314) {
+			angle = halfPiMultiple;
+		}
+		return angle;
 	}
 
 	/**
@@ -552,36 +577,36 @@ public static PVector[] lineRectIntersection(double rectWidth, double rectHeight
 	 * @param tanA  tangent of the angle of the line within rectangle
 	 * @return points of intersection
 	 */
-	private static void calcProjection(float w, float h, PVector point, float tanA, PVector[] output) {
+	private static void calcProjection(double w, double h, PVector point, double tanA, PVector[] output) {
 
-		float yCD = point.y - (tanA * (w - point.x));
-		float yAB = point.y + (tanA * point.x);
+		double yCD = point.y - (tanA * (w - point.x));
+		double yAB = point.y + (tanA * point.x);
 
 		if (tanA < 0) {
 			tanA = -tanA;
 		}
 
 		// First projection onto CD
 		if (yCD < 0) {
-			output[0].x = w + (yCD / tanA);
+			output[0].x = (float) (w + (yCD / tanA));
 		} else if (yCD > h) {
-			float opposite = yCD - h;
-			output[0].x = w - (opposite / tanA);
-			output[0].y = h;
+			double opposite = yCD - h;
+			output[0].x = (float) (w - (opposite / tanA));
+			output[0].y = (float) h;
 		} else {
-			output[0].x = w;
-			output[0].y = yCD;
+			output[0].x = (float) w;
+			output[0].y = (float) yCD;
 		}
 
 		// Second projection onto AB
 		if (yAB < 0) {
-			output[1].x = -yAB / tanA;
+			output[1].x = (float) (-yAB / tanA);
 		} else if (yAB > h) {
-			float opposite = yAB - h;
-			output[1].x = opposite / tanA;
-			output[1].y = h;
+			double opposite = yAB - h;
+			output[1].x = (float) (opposite / tanA);
+			output[1].y = (float) h;
 		} else {
-			output[1].y = yAB;
+			output[1].y = (float) yAB;
 		}
 	}
 

src/test/micycle/peasygradients/colorspace/PeasyGradientsTests.java

@@ -1,6 +1,7 @@
 package micycle.peasygradients.colorspace;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
 
@@ -32,13 +33,13 @@ void testLinearGradient() {
 		// test all values same
 		Gradient gradient = new Gradient(GREY, GREY);
 		pg.linearGradient(gradient, 0);
-		for (int i = 0; i < g.pixels.length; i++) {
-			assertEquals(GREY, g.pixels[i]);
+		for (int pixel : g.pixels) {
+			assertEquals(GREY, pixel);
 		}
 
 		// test gradient rendered monotonically
 		gradient = new Gradient(WHITE, BLACK);
-		pg.linearGradient(gradient, PConstants.TWO_PI); // also tests ange=two_pi == angle=0
+		pg.linearGradient(gradient, PConstants.TWO_PI); // also tests that angle=two_pi == angle=0
 		float[] lastCol = new float[] { 256, 256, 256 };
 		for (int i = 0; i < g.pixels.length; i++) {
 			float[] col = ColorUtils.decomposeclrRGB(g.pixels[i]);
@@ -60,16 +61,47 @@ void testLinearGradient() {
 	}
 
 	@ParameterizedTest
-	@ValueSource(ints = {1, 2, 3, 5, 50})
+	@ValueSource(doubles = { 0, 2 * Math.PI, PConstants.TWO_PI })
+	void testLinearGradientVerticalDivision(double angle) {
+		/*
+		 * Test the linear gradient division. Each half (with posterisation=2) should be
+		 * each respective color.
+		 */
+		int w = 100;
+		int h = 100;
+		PImage g = new PImage(w, h);
+		PeasyGradients pg = new PeasyGradients(g);
+		pg.posterise(2);
+
+		int colA = WHITE;
+		int colB = BLACK;
+		Gradient gradient = new Gradient(colA, colB);
+		pg.linearGradient(gradient, angle);
+
+		for (int x = 0; x < w / 2; x++) {
+			for (int y = 0; y < h; y++) {
+				assertEquals(colA, g.pixels[y * w + x], "Failed at x=" + x + ", y=" + y);
+			}
+		}
+		for (int x = w / 2; x < w; x++) {
+			for (int y = 0; y < h; y++) {
+				assertEquals(colB, g.pixels[y * w + x], "Failed at x=" + x + ", y=" + y);
+			}
+		}
+
+	}
+
+	@ParameterizedTest
+	@ValueSource(ints = { 1, 2, 3, 5, 50 })
 	void testPosterise(int n) {
-	    PImage g = new PImage(1000, 1000);
-	    PeasyGradients pg = new PeasyGradients(g);
-	    pg.posterise(n);
+		PImage g = new PImage(1000, 1000);
+		PeasyGradients pg = new PeasyGradients(g);
+		pg.posterise(n);
 
-	    Gradient gradient = new Gradient(Palette.tetradic());
-	    pg.linearGradient(gradient, 0);
+		Gradient gradient = new Gradient(Palette.tetradic());
+		pg.linearGradient(gradient, 0);
 
-	    assertEquals(n, makeUnique(g.pixels).length);
+		assertEquals(n, makeUnique(g.pixels).length);
 	}
 
 	private static int[] makeUnique(int... values) {