Auto-generated test suite

.vscode/settings.json

@@ -8,6 +8,7 @@
 		"ARGB",
 		"Bezier",
 		"BGRA",
+		"bitmapdata",
 		"bitmask",
 		"blit",
 		"Blitting",
@@ -33,6 +34,7 @@
 		"fceil",
 		"ffloor",
 		"Flixel",
+		"flxsprite",
 		"frameworking",
 		"fround",
 		"grayscale",
@@ -45,6 +47,7 @@
 		"haxeui",
 		"hxml",
 		"ifies",
+		"imagedata",
 		"interp",
 		"Ints",
 		"kernal",

CHANGELOG.md

@@ -1,3 +1,24 @@
+# 2.1.1
+
+### `Image.hx`
+ - **Added `Image.copyImageFrom`**
+
+### `vision.ds`
+ - **Added `ImageFormat.JPEG`, `ImageFormat.VISION`**
+
+### `vision.tools`
+ - **Added `ImageTools.loadFromFile` (synchronous version)**
+ - **Added `ImageTools.loadFromBytes`**
+ - **Added `ImageTools.loadFromURL`**
+ - **Added `ImageTools.exportToBytes`**
+ - **Added `ImageTools.exportToFile`**
+ - **Deprecated `ImageTools.saveToFile` in favor of `ImageTools.exportToFile`**
+
+### `vision.formats`
+  - **New Subdirectory inside the `vision` package for cleaner image format conversions**
+  - **Added `ImageIO` - reads/writes images from/to different formats/frameworks**
+  - **Added support for `jpeg` encoding for non-js platforms using `format`**
+
 # 2.1.0
 
 ### `Vision.hx`

src/VisionMain.hx

@@ -1,5 +1,6 @@
 package;
 
+import vision.formats.ImageIO;
 import vision.algorithms.SimpleHough;
 import vision.ds.Matrix2D;
 import vision.ds.Color;
@@ -35,6 +36,7 @@ using vision.tools.MathTools;
 			printImage(image);
 			printImage(image.filterForColorChannel(RED));
 
+
 			#if simple_tests
 			printSectionDivider("Simple image manipulation");
 			start = haxe.Timer.stamp();

src/vision/algorithms/BilinearInterpolation.hx

@@ -1,8 +1,6 @@
 package vision.algorithms;
 
 import vision.ds.Color;
-import vision.tools.ImageTools;
-import vision.exceptions.OutOfBounds;
 import vision.ds.Image;
 import vision.tools.MathTools.*;
 

src/vision/algorithms/Cramer.hx

@@ -2,10 +2,7 @@ package vision.algorithms;
 
 import vision.exceptions.InvalidCramerSetup;
 import vision.exceptions.InvalidCramerCoefficientsMatrix;
-import vision.tools.MathTools;
 import vision.ds.Matrix2D;
-import haxe.ds.Vector;
-import vision.ds.Array2D;
 
 /**
     Solve a system of linear equations using Cramer's rule.

src/vision/algorithms/Gauss.hx

@@ -115,7 +115,7 @@ class Gauss {
 		return kernel;
 	}
 	@:deprecated("Gaussian.createKernelOfSize() is deprecated. use Gaussian.create2DKernelOfSize() instead")
-	public static function createKernelOfSize(size:Int, sigma:Int) {
+	public static function createKernelOfSize(size:Int, sigma:Int):Array2D<Float> {
 		return create2DKernelOfSize(size, sigma);
 	}
 
@@ -172,7 +172,7 @@ class Gauss {
 		return kernel;
 	}
 
-	public static function fastBlur(image:Image, size:Int, sigma:Float) {
+	public static function fastBlur(image:Image, size:Int, sigma:Float):Image {
 		var preprocessed = image.clone();
 		#if vision_quiet
 		if (size <= 0) size = -size;

src/vision/algorithms/ImageHashing.hx

@@ -2,10 +2,8 @@ package vision.algorithms;
 
 import haxe.Int64;
 import vision.ds.Matrix2D;
-import vision.tools.ImageTools;
 import vision.ds.ByteArray;
 import vision.ds.Image;
-import vision.ds.ImageResizeAlgorithm;
 
 using vision.tools.MathTools;
 
@@ -32,7 +30,7 @@ class ImageHashing {
             }
         }
 
-        return clone.toBytes();
+        return clone.exportToBytes();
     }
 
     public static function phash(image:Image):ByteArray {

src/vision/algorithms/KMeans.hx

@@ -9,8 +9,7 @@ using vision.tools.MathTools;
 using vision.tools.ArrayTools;
 
 class KMeans {
-	public static function generateClustersUsingConvergence<T>(values:Array<T>, clusterAmount:Int, distanceFunction:(T, T) -> Float,
-			averageFunction:Array<T>->T):Array<Array<T>> {
+	public static function generateClustersUsingConvergence<T>(values:Array<T>, clusterAmount:Int, distanceFunction:(T, T) -> Float, averageFunction:Array<T>->T):Array<Array<T>> {
 		var clusterCenters = pickElementsAtRandom(values, clusterAmount, true);
 
 		// We don't use clusterAmount in case where the image doesnt have enough distinct colors to satisfy

src/vision/algorithms/Laplace.hx

@@ -7,7 +7,7 @@ import vision.ds.Image;
 
 class Laplace {
 
-    public static function convolveWithLaplacianOperator(image:Image, positive:Bool) {
+    public static function convolveWithLaplacianOperator(image:Image, positive:Bool):Image {
 		var edgeColors:Image = new Image(image.width, image.height);
 
 		for (i in 0...image.width) {
@@ -28,7 +28,7 @@ class Laplace {
 		return edgeColors;
 	}
 
-    public static function laplacianOfGaussian(image:Image, kernelSize:GaussianKernelSize, sigma:Float, threshold:Float, positive:Bool) {
+    public static function laplacianOfGaussian(image:Image, kernelSize:GaussianKernelSize, sigma:Float, threshold:Float, positive:Bool):Image {
         var returned = new Image(image.width, image.height);
         var blurred = Vision.gaussianBlur(image.clone().removeView(), sigma, kernelSize);
         var imageToProcess:Image;

src/vision/algorithms/Perwitt.hx

@@ -11,7 +11,7 @@ using vision.tools.MathTools;
  * by [Shahar Marcus](https://www.github.com/ShaharMS)
  */
 class Perwitt {
-	public static function convolveWithPerwittOperator(image:Image) {
+	public static function convolveWithPerwittOperator(image:Image):Image {
 		var edgeColors:Image = new Image(image.width, image.height);
 		var maxGradient = -1;
 
@@ -39,7 +39,7 @@ class Perwitt {
 				if (gradient > maxGradient) maxGradient = gradient;
 
 				final rgb:Int = Std.int(gradient * (255 / maxGradient));
-				//turn into ARGB
+				// turn into ARGB
 				edgeColors.setPixel(i, j, 0xff000000 | (rgb << 16) | (rgb << 8) | rgb);
 			}
 		}
@@ -62,6 +62,7 @@ class Perwitt {
 	}
 
 	// If you came here for the explanation of the algorithm, Congrats! learning is fun :D
+
 	/**
 		What does this algorithm do?
 		Basically, it takes 9 pixels chunks each time it performs a calculation, and tries to see how different the
@@ -82,38 +83,36 @@ class Perwitt {
 		Now, if this value is greater than the threshold, then we declare it an edge. now, were gonna do the same thing
 		for all chunks of the image, and from top to bottom too if needed.
 	**/
-	public static function detectEdges(image:Image, threshold:Float) {
-
-
-			var edges = new Image(image.width, image.height, Color.fromRGBA(0, 0, 0));
-			var blackAndWhite = Vision.grayscale(image.clone());
-			for (x in 0...blackAndWhite.width) {
-				for (y in 0...blackAndWhite.height) {
-					var neighbors = [
-						blackAndWhite.getSafePixel(x - 1, y - 1),
-						blackAndWhite.getSafePixel(x, y - 1),
-						blackAndWhite.getSafePixel(x + 1, y - 1),
-						blackAndWhite.getSafePixel(x - 1, y),
-						blackAndWhite.getSafePixel(x, y),
-						blackAndWhite.getSafePixel(x + 1, y),
-						blackAndWhite.getSafePixel(x - 1, y + 1),
-						blackAndWhite.getSafePixel(x, y + 1),
-						blackAndWhite.getSafePixel(x + 1, y + 1)
-					];
-					final perwittCalculationIterationLTR = neighbors[0].red * -1
-						+ neighbors[3].red * -1 + neighbors[6].red * -1 + neighbors[2].red * 1 + neighbors[5].red * 1 + neighbors[8].red * 1;
-					if (Math.abs(perwittCalculationIterationLTR) > threshold) {
-						edges.setPixel(x, y, Color.fromRGBA(255, 255, 255));
-						continue;
-					}
-					final perwittCalculationIterationTTB = neighbors[0].red * -1
-						+ neighbors[1].red * -1 + neighbors[2].red * -1 + neighbors[6].red * 1 + neighbors[7].red * 1 + neighbors[8].red * 1;
-					if (Math.abs(perwittCalculationIterationTTB) > threshold) {
-						edges.setPixel(x, y, Color.fromRGBA(255, 255, 255));
-						continue;
-					}
+	public static function detectEdges(image:Image, threshold:Float):Image {
+		var edges = new Image(image.width, image.height, Color.fromRGBA(0, 0, 0));
+		var blackAndWhite = Vision.grayscale(image.clone());
+		for (x in 0...blackAndWhite.width) {
+			for (y in 0...blackAndWhite.height) {
+				var neighbors = [
+					blackAndWhite.getSafePixel(x - 1, y - 1),
+					blackAndWhite.getSafePixel(x, y - 1),
+					blackAndWhite.getSafePixel(x + 1, y - 1),
+					blackAndWhite.getSafePixel(x - 1, y),
+					blackAndWhite.getSafePixel(x, y),
+					blackAndWhite.getSafePixel(x + 1, y),
+					blackAndWhite.getSafePixel(x - 1, y + 1),
+					blackAndWhite.getSafePixel(x, y + 1),
+					blackAndWhite.getSafePixel(x + 1, y + 1)
+				];
+				final perwittCalculationIterationLTR = neighbors[0].red * -1
+					+ neighbors[3].red * -1 + neighbors[6].red * -1 + neighbors[2].red * 1 + neighbors[5].red * 1 + neighbors[8].red * 1;
+				if (Math.abs(perwittCalculationIterationLTR) > threshold) {
+					edges.setPixel(x, y, Color.fromRGBA(255, 255, 255));
+					continue;
+				}
+				final perwittCalculationIterationTTB = neighbors[0].red * -1
+					+ neighbors[1].red * -1 + neighbors[2].red * -1 + neighbors[6].red * 1 + neighbors[7].red * 1 + neighbors[8].red * 1;
+				if (Math.abs(perwittCalculationIterationTTB) > threshold) {
+					edges.setPixel(x, y, Color.fromRGBA(255, 255, 255));
+					continue;
 				}
 			}
-			return edges;
+		}
+		return edges;
 	}
 }

src/vision/algorithms/Radix.hx

@@ -84,7 +84,7 @@ class Radix {
 	/**
 		Sorts an array of `Int`s / `UInt`s / `Int64` using **Radix Sort**.
 	**/
-	public static overload extern inline function sort(main:Array<Int>) {
+	overload extern public static inline function sort(main:Array<Int>):Array<Int> {
 
 		var negatives = [], positives = [];
 		for (i in 0...main.length) {
@@ -113,7 +113,7 @@ class Radix {
 		return main = negatives.concat(positives);
 	}
 
-	public static overload extern inline function sort(main:Array<UInt>) {
+	overload extern public static inline function sort(main:Array<UInt>):Array<UInt> {
 		// Find the maximum number to know the number of digits
 		final max = getMax(main, main.length);
 		var exp = 1;
@@ -129,7 +129,7 @@ class Radix {
 		return main;
 	}
 
-	public static overload extern inline function sort(main:Array<Int64>) {
+	overload extern public static inline function sort(main:Array<Int64>):Array<Int64> {
 
 		var negatives = [], positives = [];
 		for (i in 0...main.length) {

src/vision/algorithms/RobertsCross.hx

@@ -13,7 +13,7 @@ import vision.ds.Image;
 **/
 class RobertsCross {
 
-    public static function convolveWithRobertsCross(image:Image) {
+    public static function convolveWithRobertsCross(image:Image):Image {
 		var edgeColors:Image = new Image(image.width, image.height);
 		var maxGradient = -1;
 

src/vision/algorithms/SimpleHough.hx

@@ -34,7 +34,7 @@ class SimpleHough {
         return rays;
     }
 
-    public static function mapLines(image:Image, rays:Array<Ray2D>) {
+    public static function mapLines(image:Image, rays:Array<Ray2D>):Image {
         for (ray in rays) {
             image.drawRay2D(ray, Color.CYAN);
         }

src/vision/algorithms/SimpleLineDetector.hx

@@ -174,7 +174,7 @@ class SimpleLineDetector {
 		return lines;
 	}
 
-	static extern inline function p(x:Int = 0, y:Int = 0) {
+	static extern inline function p(x:Int = 0, y:Int = 0):Int16Point2D {
 		return new Int16Point2D(x, y);
 	}
 

src/vision/algorithms/Sobel.hx

@@ -11,7 +11,7 @@ using vision.tools.MathTools;
 	by [Shahar Marcus](https://www.github.com/ShaharMS)
 **/
 class Sobel {
-	public static function convolveWithSobelOperator(image:Image) {
+	public static function convolveWithSobelOperator(image:Image):Image {
 		var edgeColors:Image = new Image(image.width, image.height);
 		var maxGradient = -1;
 
@@ -68,7 +68,7 @@ class Sobel {
 		If this value is greater than the threshold, then we declare it an edge. now, were gonna do the same thing
 		for all chunks of the image, and from top to bottom too if needed.
 	**/
-	public static function detectEdges(image:Image, threshold:Float) {
+	public static function detectEdges(image:Image, threshold:Float):Image {
 		final edges = new Image(image.width, image.height, Color.fromRGBA(0, 0, 0));
 		final blackAndWhite = Vision.grayscale(image.clone());
 		for (x in 0...blackAndWhite.width) {

src/vision/ds/Array2D.hx

@@ -1,5 +1,6 @@
 package vision.ds;
 
+import haxe.iterators.ArrayIterator;
 #if !vision_fancy_array_access
 /**
 	A 2D array, faster than an `Array<Array<T>>`.
@@ -106,7 +107,7 @@ class Array2D<T> {
 
 		`(x, y)...(x + 5, y) -> (x, y + 1)...(x + 5, y + 1) -> (x, y + 2)...`
 	**/
-	public inline function iterator() {
+	public inline function iterator():ArrayIterator<T> {
 		return inner.iterator();
 	}