More tests, new macro protection for targets vulnerable to excessive inlining

Author: ShaharMS

.github/workflows/main.yml

@@ -121,7 +121,7 @@ jobs:
       - name: Compile (${{ matrix.target }})
         run: |
           mkdir -p bin
-          CMD="haxe --class-path tests/generated/src --main Main --library vision --library format --library utest -debug"
+          CMD="haxe --class-path tests/generated/src --main Main --library vision --library format --library utest -debug -D vision_skip_golden -D vision_skip_invalid_tests"
           if [ "${{ matrix.target }}" = "java" ] || [ "${{ matrix.target }}" = "jvm" ]; then
             CMD="$CMD --no-inline"
           fi

CHANGELOG.md

@@ -1,4 +1,4 @@
-# 2.1.1
+# 2.2.0
 
 ### `Image.hx`
  - **Added `Image.copyImageFrom`**

README.md

@@ -269,3 +269,4 @@ If you see some code that you think is not understandable, or some place that la
 | `vision_higher_width_cap` | allows using images wider than 65535 pixels, but makes the image byte offset bigger (11 to 21 bytes) (for more information about the byte offset, [click here](https://github.com/ShaharMS/Vision/blob/ed042871963e7456161c00017e4c2bf79a1f26cc/src/vision/ds/Image.hx#L37)). Also allows image views to be wider & taller than 65535 pixels. | 1.2.0 - now |
 | `vision_fancy_array_access` | Enables a fancy, shortened way to access arrays of multi-dimensional arrays (specifically Array2D) using double square brackets: `array[[x, y]]`. This is enabled by default. When disabled, only direct `get` and `set` calls are allowed. | 2.0.0 - now |
 | `vision_hlc_color_compile` | When compiling to C code using the C transpiler of Hashlink, the word TRANSPARENT can clash with existing `#define`s in the resulting C code. To work around this, the defines disables `Color.TRANSPARENT`. You can use `Color.TRANSPARENT_COLOR` instead. | 2.0.0 - now |
+| `vision_disable_inline_protection` | Disables the inline-stripping build macro used on java, jvm, and lua targets. Leave this off unless you explicitly want inline fields preserved on those targets. Pay attention - inlining was disabled on these targets because of errors related to variable count/function size | 2.2.0 - now |

compile.hxml

@@ -27,4 +27,5 @@
 
 #--define vision_fancy_array_access
 --macro addGlobalMetadata('', '@:build(vision.helpers.Array2DMacro.build())')
+--macro addGlobalMetadata('', '@:build(vision.helpers.InlineProtectionMacro.build())')
 

extraParams.hxml

@@ -1,3 +1,4 @@
 # https://github.com/Laerdal/opentype.hx/issues/2
 # --resource assets/NotoSans-Regular.ttf
---macro addGlobalMetadata('', '@:build(vision.helpers.Array2DMacro.build())')
+--macro addGlobalMetadata('', '@:build(vision.helpers.Array2DMacro.build())')
+--macro addGlobalMetadata('', '@:build(vision.helpers.InlineProtectionMacro.build())')

haxelib.json

@@ -1,7 +1,7 @@
 {
     "name": "vision",
     "license": "MIT",
-    "version": "2.1.0",   
+    "version": "2.2.0",   
     "description": "Vision is a simple, powerful and flexible computer vision & image processing library for Haxe.",
     "contributors": ["ShaharMS"],
     "releasenote": "K-Means, color filtering, Image hashing, and many QOL additions :D",

src/vision/ds/Image.hx

@@ -112,6 +112,7 @@ abstract Image(ByteArray) {
 		@param color The color to fill the image with. if unspecified, the image is transparent.
 	**/
 	public inline function new(width:Int, height:Int, color:Color = 0x00000000) {
+	#end
 		this = new ByteArray(width * height * 4 + OFFSET);
 		#if vision_higher_width_cap this.setInt32 #else this.setUInt16 #end (0, width);
 		#if vision_higher_width_cap this.setInt32 #else this.setUInt16 #end (WIDTH_BYTES, 0);
@@ -131,7 +132,13 @@ abstract Image(ByteArray) {
 
 	inline function getColorFromStartingBytePos(position:Int):Color {
 		position += OFFSET;
-		return new Color(this[position] << 24 | this[position + 1] << 16 | this[position + 2] << 8 | this[position + 3]); 
+		var value = this[position] << 24 | this[position + 1] << 16 | this[position + 2] << 8 | this[position + 3];
+		#if (python || php || lua)
+		var signedValue:haxe.Int32 = value;
+		signedValue = signedValue + 0;
+		value = signedValue;
+		#end
+		return new Color(value);
 	}
 
 	inline function setColorFromStartingBytePos(position:Int, c:Color) {
@@ -616,8 +623,15 @@ abstract Image(ByteArray) {
 		@see Ray2D
 	**/
 	public inline function drawRay2D(line:Ray2D, color:Color) {
-		var p1 = IntPoint2D.fromPoint2D(line.getPointAtY(0));
-		var p2 = IntPoint2D.fromPoint2D(line.getPointAtY(height - 1));
+		var p1:IntPoint2D;
+		var p2:IntPoint2D;
+		if (line.slope == 0) {
+			p1 = new IntPoint2D(0, Std.int(line.point.y));
+			p2 = new IntPoint2D(width - 1, Std.int(line.point.y));
+		} else {
+			p1 = IntPoint2D.fromPoint2D(line.getPointAtY(0));
+			p2 = IntPoint2D.fromPoint2D(line.getPointAtY(height - 1));
+		}
 		var x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y;
 		var dx = Math.abs(x2 - x1);
 		var dy = Math.abs(y2 - y1);
@@ -737,8 +751,8 @@ abstract Image(ByteArray) {
 		}
 
 		var p0 = IntPoint2D.fromPoint2D(line.start);
-		var p1 = IntPoint2D.fromPoint2D(line.end);
-		var p2 = IntPoint2D.fromPoint2D(control);
+		var p1 = IntPoint2D.fromPoint2D(control);
+		var p2 = IntPoint2D.fromPoint2D(line.end);
 		var i = 0.;
 		var step = 1 / accuracy;
 		while (i <= 1) {
@@ -748,6 +762,8 @@ abstract Image(ByteArray) {
 			}
 			i += step;
 		}
+		if (hasPixel(p0.x, p0.y)) setPixel(p0.x, p0.y, color);
+		if (hasPixel(p2.x, p2.y)) setPixel(p2.x, p2.y, color);
 	}
 
 	/**
@@ -779,16 +795,21 @@ abstract Image(ByteArray) {
 			return {x: x, y: y};
 		}
 
+		var p0 = IntPoint2D.fromPoint2D(line.start);
+		var p3 = IntPoint2D.fromPoint2D(line.end);
+		var p1 = IntPoint2D.fromPoint2D(control1);
+		var p2 = IntPoint2D.fromPoint2D(control2);
 		var i = 0.;
 		var step = 1 / accuracy;
-		while (i < 1) {
-			var p =
-			inline bezier(i, line.start, line.end, control1, control2);
+		while (i <= 1) {
+			var p = inline bezier(i, p0, p1, p2, p3);
 			if (hasPixel(p.x, p.y)) {
 				setPixel(p.x, p.y, color);
 			}
 			i += step;
 		}
+		if (hasPixel(p0.x, p0.y)) setPixel(p0.x, p0.y, color);
+		if (hasPixel(p3.x, p3.y)) setPixel(p3.x, p3.y, color);
 	}
 
 	// https://github.com/Laerdal/opentype.hx/issues/2
@@ -1656,7 +1677,7 @@ abstract Image(ByteArray) {
 }
 
 private class PixelIterator {
-	var i = 4;
+	var i = 0;
 	var img:Image;
 
 	public inline function new(img:Image) {
@@ -1667,11 +1688,11 @@ private class PixelIterator {
 		final x = i % img.width;
 		final y = Math.floor(i / img.width);
 		var pixel:Pixel = {x: x, y: y, color: img.getPixel(x, y)};
-		i += 4;
+		i++;
 		return pixel;
 	}
 
 	public inline function hasNext():Bool {
-		return i < (cast img:ByteArray).length;
+		return i < (img.width * img.height);
 	}
 }

src/vision/helpers/InlineProtectionMacro.hx

@@ -0,0 +1,44 @@
+package vision.helpers;
+
+#if macro
+import haxe.macro.Context;
+import haxe.macro.Expr;
+
+class InlineProtectionMacro {
+    public static function build():Array<Field> {
+        if (Context.defined("vision_disable_inline_protection")) {
+            return null;
+        }
+        var isTarget = Context.defined("java") || Context.defined("jvm") || Context.defined("lua");
+        if (!isTarget) {
+            return null;
+        }
+
+        var fields = Context.getBuildFields();
+        for (field in fields) {
+            var access = field.access;
+            if (access == null) {
+                continue;
+            }
+            var hasInline = false;
+            for (entry in access) {
+                if (entry == AInline) {
+                    hasInline = true;
+                    break;
+                }
+            }
+            if (!hasInline) {
+                continue;
+            }
+            var filtered:Array<Access> = [];
+            for (entry in access) {
+                if (entry != AInline) {
+                    filtered.push(entry);
+                }
+            }
+            field.access = filtered;
+        }
+        return fields;
+    }
+}
+#end

test.hxml

@@ -1,4 +1,5 @@
---class-path tests/generated/src
+--cwd tests/generated
+--class-path src
 --main Main
 
 --library vision