(#68) Turned a few anonymous functions into named ones

Author: s1hofmann

Diff for: lib/provider/opencv/determine-searchregion.function.ts

@@ -1,11 +1,11 @@
 import { MatchRequest } from "../../match-request.class";
 import { Region } from "../../region.class";
 
-export const determineScaledSearchRegion = (matchRequest: MatchRequest): Region => {
+export function determineScaledSearchRegion(matchRequest: MatchRequest): Region {
   const searchRegion = matchRequest.searchRegion;
   const scaleX = matchRequest.haystack.pixelDensity.scaleX || 1.0;
   const scaleY = matchRequest.haystack.pixelDensity.scaleY || 1.0;
   searchRegion.width *= scaleX;
   searchRegion.height *= scaleY;
   return searchRegion;
-};
+}

Diff for: lib/provider/opencv/find-edges.function.ts

@@ -1,6 +1,6 @@
 import * as cv from "opencv4nodejs-prebuilt";
 
-export const findEdges = async (image: cv.Mat): Promise<cv.Mat> => {
+export async function findEdges(image: cv.Mat): Promise<cv.Mat> {
   const gray = await image.cvtColorAsync(cv.COLOR_BGR2GRAY);
   return gray.cannyAsync(50, 200);
-};
+}

Diff for: lib/provider/opencv/image-processor.class.ts

@@ -2,13 +2,13 @@ import * as cv from "opencv4nodejs-prebuilt";
 import { Image } from "../../image.class";
 import { Region } from "../../region.class";
 
-const determineROI = (img: Image, roi: Region): cv.Rect => {
+function determineROI(img: Image, roi: Region): cv.Rect {
   return new cv.Rect(
     Math.min(Math.max(roi.left, 0), img.width),
     Math.min(Math.max(roi.top, 0), img.height),
     Math.min(roi.width, img.width - roi.left),
     Math.min(roi.height, img.height - roi.top));
-};
+}
 
 export class ImageProcessor {
   /**

Diff for: lib/provider/opencv/match-image.function.ts

@@ -2,7 +2,7 @@ import * as cv from "opencv4nodejs-prebuilt";
 import { MatchResult } from "../../match-result.class";
 import { Region } from "../../region.class";
 
-export const matchImages = async (haystack: cv.Mat, needle: cv.Mat): Promise<MatchResult> => {
+export async function matchImages(haystack: cv.Mat, needle: cv.Mat): Promise<MatchResult> {
   const match = await haystack.matchTemplateAsync(
     needle,
     cv.TM_SQDIFF_NORMED,
@@ -17,4 +17,4 @@ export const matchImages = async (haystack: cv.Mat, needle: cv.Mat): Promise<Mat
       needle.rows,
     ),
   );
-};
+}

Diff for: lib/provider/opencv/scale-image.function.ts

@@ -1,9 +1,9 @@
 import * as cv from "opencv4nodejs-prebuilt";
 import { lowerBound } from "./bound-value.function";
 
-export const scaleImage = async (image: cv.Mat, scaleFactor: number): Promise<cv.Mat> => {
+export async function scaleImage(image: cv.Mat, scaleFactor: number): Promise<cv.Mat> {
   const boundScaleFactor = lowerBound(scaleFactor, 0.0, 1.0);
   const scaledRows = Math.floor(image.rows * boundScaleFactor);
   const scaledCols = Math.floor(image.cols * boundScaleFactor);
   return image.resizeAsync(scaledRows, scaledCols, 0, 0, cv.INTER_AREA);
-};
+}

Diff for: lib/provider/opencv/scale-location.function.ts

@@ -1,15 +1,15 @@
 import { Region } from "../../region.class";
 import { lowerBound } from "./bound-value.function";
 
-export const scaleLocation = (
+export function scaleLocation(
   result: Region,
   scaleFactor: number,
-): Region => {
+): Region {
   const boundScaleFactor = lowerBound(scaleFactor, 0.0, 1.0);
   return new Region(
     result.left / boundScaleFactor,
     result.top / boundScaleFactor,
     result.width,
     result.height,
   );
-};
+}

Diff for: lib/provider/opencv/template-matching-finder.class.ts

@@ -14,14 +14,14 @@ import { matchImages } from "./match-image.function";
 import { scaleImage } from "./scale-image.function";
 import { scaleLocation } from "./scale-location.function";
 
-const loadNeedle = async (image: Image): Promise<cv.Mat> => {
+async function loadNeedle(image: Image): Promise<cv.Mat> {
   if (image.hasAlphaChannel) {
     return ImageProcessor.fromImageWithAlphaChannel(image);
   }
   return ImageProcessor.fromImageWithoutAlphaChannel(image);
-};
+}
 
-const loadHaystack = async (matchRequest: MatchRequest): Promise<cv.Mat> => {
+async function loadHaystack(matchRequest: MatchRequest): Promise<cv.Mat> {
   const searchRegion = determineScaledSearchRegion(matchRequest);
   if (matchRequest.haystack.hasAlphaChannel) {
     return ImageProcessor.fromImageWithAlphaChannel(
@@ -34,9 +34,9 @@ const loadHaystack = async (matchRequest: MatchRequest): Promise<cv.Mat> => {
       searchRegion,
     );
   }
-};
+}
 
-const debugImage = (image: cv.Mat, filename: string, suffix?: string) => {
+function debugImage(image: cv.Mat, filename: string, suffix?: string) {
   const parsedPath = path.parse(filename);
   let fullFilename = parsedPath.name;
   if (suffix) {
@@ -45,20 +45,20 @@ const debugImage = (image: cv.Mat, filename: string, suffix?: string) => {
   fullFilename += parsedPath.ext;
   const fullPath = path.join(parsedPath.dir, fullFilename);
   cv.imwriteAsync(fullPath, image);
-};
+}
 
-// const debugResult = (image: cv.Mat, result: MatchResult, filename: string, suffix?: string) => {
+// function debugResult(image: cv.Mat, result: MatchResult, filename: string, suffix?: string) {
 //   const roiRect = new cv.Rect(
 //     Math.min(Math.max(result.location.left, 0), image.cols),
 //     Math.min(Math.max(result.location.top, 0), image.rows),
 //     Math.min(result.location.width, image.cols - result.location.left),
 //     Math.min(result.location.height, image.rows - result.location.top));
 //   debugImage(image.getRegion(roiRect), filename, suffix);
-// };
+// }
 
-const isValidSearch = (needle: cv.Mat, haystack: cv.Mat): boolean => {
+function isValidSearch(needle: cv.Mat, haystack: cv.Mat): boolean {
   return (needle.cols <= haystack.cols) && (needle.rows <= haystack.rows);
-};
+}
 
 export class TemplateMatchingFinder implements FinderInterface {
   private initialScale = [1.0];