Updated finder interface and implementation according to restructured code

Author: s1hofmann

lib/provider/opencv/finder.interface.ts

@@ -1,7 +1,5 @@
-import { Image } from "../../image.class";
 import { MatchRequest } from "../../match-request.class";
 import { MatchResult } from "../../match-result.class";
-import { Region } from "../../region.class";
 
 /**
  * A Finder should provide an abstraction layer to perform
@@ -10,15 +8,6 @@ import { Region } from "../../region.class";
  * @interface FinderInterface
  */
 export interface FinderInterface {
-  /**
-   * loadImage should allow to load an image from filesystem
-   *
-   * @param {string} path The filesystem path to the image
-   * @returns {*} An image
-   * @memberof VisionProviderInterface
-   */
-  loadImage(path: string): any;
-
   /**
    * findMatch should provide an abstraction to search for an image needle
    * in another image haystack
@@ -38,35 +27,4 @@ export interface FinderInterface {
    * @memberof FinderInterface
    */
   findMatches(matchRequest: MatchRequest): Promise<MatchResult[]>;
-
-  /**
-   * fromImageWithAlphaChannel should provide a way to create a library specific
-   * image with alpha channel from an abstract Image object holding raw data and image dimension
-   *
-   * @param {Image} img The input Image
-   * @param {Region} [roi] An optional Region to specify a ROI
-   * @returns {Promise<any>} An image
-   * @memberof VisionProviderInterface
-   */
-  fromImageWithAlphaChannel(img: Image, roi?: Region): Promise<any>;
-
-  /**
-   * fromImageWithoutAlphaChannel should provide a way to create a library specific
-   * image without alpha channel from an abstract Image object holding raw data and image dimension
-   *
-   * @param {Image} img The input Image
-   * @param {Region} [roi] An optional Region to specify a ROI
-   * @returns {Promise<any>} An image
-   * @memberof VisionProviderInterface
-   */
-  fromImageWithoutAlphaChannel(img: Image, roi?: Region): Promise<any>;
-
-  /**
-   * rgbToGrayScale should provide a way to convert an image from RGB to grayscale
-   *
-   * @param {*} img Input image, RGB
-   * @returns {Promise<any>} Output image, grayscale
-   * @memberof VisionProviderInterface
-   */
-  rgbToGrayScale(img: any): Promise<any>;
 }

lib/provider/opencv/template-matching-finder.class.spec.ts

@@ -2,43 +2,19 @@ import * as path from "path";
 import { Image } from "../../image.class";
 import { MatchRequest } from "../../match-request.class";
 import { Region } from "../../region.class";
+import { ImageReader } from "./image-reader.class";
 import { TemplateMatchingFinder } from "./template-matching-finder.class";
 
 describe("Template-matching finder", () => {
-  it("loadImage should resolve to a non-empty Mat on successful load", async () => {
-    // GIVEN
-    const SUT = new TemplateMatchingFinder();
-    const imagePath = path.resolve(__dirname, "./__mocks__/mouse.png");
-
-    // WHEN
-    const result = await SUT.loadImage(imagePath);
-
-    // THEN
-    expect(result.rows).toBeGreaterThan(0);
-    expect(result.cols).toBeGreaterThan(0);
-    expect(result.empty).toBeFalsy();
-  });
-
-  it("loadImage should reject on unsuccessful load", async () => {
-    // GIVEN
-    const SUT = new TemplateMatchingFinder();
-    const imagePath = "./__mocks__/foo.png";
-
-    // WHEN
-    const call = SUT.loadImage;
-
-    // THEN
-    await expect(call(imagePath)).rejects.toEqual("empty Mat");
-  });
-
   it("findMatch should return a match when present in image", async () => {
     // GIVEN
+    const imageLoader = new ImageReader();
     const SUT = new TemplateMatchingFinder();
     const imagePath = path.resolve(__dirname, "./__mocks__/mouse.png");
-    const needle = await SUT.loadImage(imagePath);
+    const needle = await imageLoader.load(imagePath);
     const minConfidence = 0.99;
-    const searchRegion = new Region(0, 0, needle.cols, needle.rows);
-    const haystack = new Image(needle.cols, needle.rows, needle.getData(), 3);
+    const searchRegion = new Region(0, 0, needle.width, needle.height);
+    const haystack = new Image(needle.width, needle.height, needle.data, 3);
     const matchRequest = new MatchRequest(haystack, imagePath, searchRegion, minConfidence);
 
     // WHEN
@@ -51,12 +27,13 @@ describe("Template-matching finder", () => {
 
   it("findMatch should return a match within a search region when present in image", async () => {
     // GIVEN
+    const imageLoader = new ImageReader();
     const SUT = new TemplateMatchingFinder();
     const imagePath = path.resolve(__dirname, "./__mocks__/mouse.png");
-    const needle = await SUT.loadImage(imagePath);
+    const needle = await imageLoader.load(imagePath);
     const minConfidence = 0.99;
     const searchRegion = new Region(10, 20, 100, 100);
-    const haystack = new Image(needle.cols, needle.rows, needle.getData(), 3);
+    const haystack = new Image(needle.width, needle.height, needle.data, 3);
     const matchRequest = new MatchRequest(haystack, imagePath, searchRegion, minConfidence);
 
     // WHEN
@@ -69,13 +46,20 @@ describe("Template-matching finder", () => {
 
   it("findMatch should throw on invalid image paths", async () => {
     // GIVEN
+    const imageLoader = new ImageReader();
     const SUT = new TemplateMatchingFinder();
-    const imagePath = path.resolve(__dirname, "./__mocks__/foo.png");
+    const pathToNeedle = path.resolve(__dirname, "./__mocks__/mouse.png");
+    const pathToHaystack = "./__mocks__/foo.png";
+    const needle = await imageLoader.load(pathToNeedle);
+    const minConfidence = 0.99;
+    const searchRegion = new Region(0, 0, 100, 100);
+    const haystack = new Image(needle.width, needle.height, needle.data, 3);
+    const matchRequest = new MatchRequest(haystack, pathToHaystack, searchRegion, minConfidence);
 
     // WHEN
-    const call = await SUT.loadImage;
+    const result = SUT.findMatch(matchRequest);
 
     // THEN
-    await expect(call(imagePath)).rejects.toEqual("empty Mat");
+    expect(result).rejects.toEqual(`Failed to load image from '${pathToHaystack}'`);
   });
 });

lib/provider/opencv/template-matching-finder.class.ts

@@ -4,7 +4,10 @@ import { Image } from "../../image.class";
 import { MatchRequest } from "../../match-request.class";
 import { MatchResult } from "../../match-result.class";
 import { Region } from "../../region.class";
+import { DataSource } from "./data-source.interface";
 import { FinderInterface } from "./finder.interface";
+import { ImageProcessor } from "./image-processor.class";
+import { ImageReader } from "./image-reader.class";
 
 export class TemplateMatchingFinder implements FinderInterface {
   private static scaleStep = 0.5;
@@ -101,19 +104,23 @@ export class TemplateMatchingFinder implements FinderInterface {
   }
 
   private static async debugResult(image: cv.Mat, result: MatchResult, filename: string, suffix?: string) {
-      const roiRect = new cv.Rect(
-        result.location.left,
-        result.location.top,
-        result.location.width,
-        result.location.height);
-      this.debugImage(image.getRegion(roiRect), filename, suffix);
+    const roiRect = new cv.Rect(
+      result.location.left,
+      result.location.top,
+      result.location.width,
+      result.location.height);
+    this.debugImage(image.getRegion(roiRect), filename, suffix);
   }
 
-  constructor() {
+  constructor(
+    private source: DataSource = new ImageReader(),
+  ) {
   }
 
   public async findMatches(matchRequest: MatchRequest, debug: boolean = false): Promise<MatchResult[]> {
-    const needle = await this.loadImage(matchRequest.pathToNeedle);
+    const needle = await this.loadNeedle(
+      await this.source.load(matchRequest.pathToNeedle)
+    );
     if (needle.empty) {
       throw new Error(
         `Failed to load ${matchRequest.pathToNeedle}, got empty image.`,
@@ -178,59 +185,30 @@ export class TemplateMatchingFinder implements FinderInterface {
 
   public async findMatch(matchRequest: MatchRequest, debug: boolean = false): Promise<MatchResult> {
     const matches = await this.findMatches(matchRequest, debug);
-    if (matches.length === 0) {
-      throw new Error(
-        `Unable to locate ${matchRequest.pathToNeedle}, no match!`,
-      );
-    }
-    return matches[0];
-  }
-
-  public async loadImage(imagePath: string): Promise<cv.Mat> {
-    return cv.imreadAsync(imagePath);
-  }
-
-  public async fromImageWithAlphaChannel(
-    img: Image,
-    roi?: Region,
-  ): Promise<cv.Mat> {
-    const mat = await new cv.Mat(img.data, img.height, img.width, cv.CV_8UC4).cvtColorAsync(cv.COLOR_BGRA2BGR);
-    if (roi) {
-      return Promise.resolve(
-        mat.getRegion(new cv.Rect(roi.left, roi.top, roi.width, roi.height)),
-      );
-    } else {
-      return Promise.resolve(mat);
-    }
-  }
-
-  public async rgbToGrayScale(img: cv.Mat): Promise<cv.Mat> {
-    return img.cvtColorAsync(cv.COLOR_BGR2GRAY);
+    return new Promise<MatchResult>((resolve, reject) => {
+      if (matches.length === 0) {
+        reject(`Unable to locate ${matchRequest.pathToNeedle}, no match!`);
+      }
+      resolve(matches[0]);
+    });
   }
 
-  public async fromImageWithoutAlphaChannel(
-    img: Image,
-    roi?: Region,
-  ): Promise<cv.Mat> {
-    const mat = new cv.Mat(img.data, img.height, img.width, cv.CV_8UC3);
-    if (roi) {
-      return Promise.resolve(
-        mat.getRegion(new cv.Rect(roi.left, roi.top, roi.width, roi.height)),
-      );
-    } else {
-      return Promise.resolve(mat);
+  private async loadNeedle(image: Image): Promise<cv.Mat> {
+    if (image.hasAlphaChannel) {
+      return ImageProcessor.fromImageWithAlphaChannel(image);
     }
+    return ImageProcessor.fromImageWithoutAlphaChannel(image);
   }
 
   private async loadHaystack(matchRequest: MatchRequest): Promise<cv.Mat> {
     const searchRegion = TemplateMatchingFinder.determineScaledSearchRegion(matchRequest);
     if (matchRequest.haystack.hasAlphaChannel) {
-      return await this.fromImageWithAlphaChannel(
+      return ImageProcessor.fromImageWithAlphaChannel(
         matchRequest.haystack,
         searchRegion,
       );
     } else {
-      return await this.fromImageWithoutAlphaChannel(
+      return ImageProcessor.fromImageWithoutAlphaChannel(
         matchRequest.haystack,
         searchRegion,
       );