feat(weber): add Weber SSIM (follow-up) (#271)

- This comment is a cleanup / formatting commit
- Flagged as "feat" to ensure we trigger a minor version from the
  previous one, which did add the Weber approach but somehow didn't
  trigger a release

package.json

@@ -6,7 +6,7 @@
   "browser": "dist/ssim.web",
   "version": "0.0.0-semantically-released",
   "scripts": {
-    "format-all": "git ls-files {src,spec}*.{js,json} | xargs yarn format",
+    "format-all": "git ls-files {src,spec}*.{ts,js,json} | xargs yarn format",
     "format": "prettier --write --single-quote --no-semi --trailing-comma es5",
     "commit": "git-cz",
     "test": "jest --testTimeout=500000",
@@ -77,4 +77,4 @@
       "path": "node_modules/cz-conventional-changelog"
     }
   }
-}
+}

spec/e2e/ivc.spec.ts

@@ -15,14 +15,14 @@ describe("IVC", () => {
     const expected = await getJSONScores(scores, path, "bmp");
     const results = Object.entries(expected)
       .map(([key, { file, reference }]): [string, number] => {
-        const { mssim } = ssim(reference, file, {ssim: "fast"});
+        const { mssim } = ssim(reference, file, { ssim: "fast" });
 
         return [key, roundTo(mssim, 3)];
       })
       .reduce(
         (acc, [key, result]) => ({
           ...acc,
-          [key]: result
+          [key]: result,
         }),
         {} as MSSIMValues
       );
@@ -41,14 +41,12 @@ describe("IVC", () => {
       .reduce(
         (acc, [key, result]) => ({
           ...acc,
-          [key]: result
+          [key]: result,
         }),
         {} as MSSIMValues
       );
-    //
+
     const end = new Date().getTime();
-    // console.log(`Weber Total Time: ${end-start}`);
-    // console.log(`Weber Mean time: ${(end-start)/Object.keys(scores).length}`);
     const referenceScores = scores as MSSIMValues;
     const newV: any = {};
     let newMean = 0;
@@ -60,19 +58,18 @@ describe("IVC", () => {
       newV[score] = {
         mssim: weberNewVal,
         distance: distWeberNew,
-        ref: refVal
+        ref: refVal,
       };
-      const newMeanR = newMean + (distWeberNew - newMean) / Object.keys(newV).length;
+      const newMeanR =
+        newMean + (distWeberNew - newMean) / Object.keys(newV).length;
       newS = newS + (distWeberNew - newMean) * (distWeberNew - newMeanR);
       newMean = newMeanR;
     }
 
-
     const newVar = newS / (Object.keys(newV).length - 1);
-    // console.log(`mean: ${newMean} variance: ${newVar}`);
-    // These came from the the calculated variances from the above commented console log
-    expect(roundTo(newMean,4 )).toEqual(0.0202);
-    expect(roundTo(newVar, 6)).toEqual(0.000211);
+
+    expect(roundTo(newMean, 4)).toMatchInlineSnapshot(`0.0202`);
+    expect(roundTo(newVar, 6)).toMatchInlineSnapshot(`0.000211`);
     expect(results).toEqual(weberScores as MSSIMValues);
   }, 70000);
 
@@ -87,14 +84,11 @@ describe("IVC", () => {
       .reduce(
         (acc, [key, result]) => ({
           ...acc,
-          [key]: result
+          [key]: result,
         }),
         {} as MSSIMValues
       );
-    //
     const end = new Date().getTime();
-    // console.log(`Bezkrovny Total Time: ${end-start}`);
-    // console.log(`Bezkrovny Mean time: ${(end-start)/Object.keys(scores).length}`);
 
     const referenceScores = scores as MSSIMValues;
     const newV: any = {};
@@ -107,19 +101,15 @@ describe("IVC", () => {
       newV[score] = {
         mssim: newVal,
         distance: distNew,
-        ref: refVal
+        ref: refVal,
       };
       const meanR = newMean + (distNew - newMean) / Object.keys(newV).length;
       newS = newS + (distNew - newMean) * (distNew - meanR);
       newMean = meanR;
     }
     const newVar = newS / (Object.keys(newV).length - 1);
-    // console.log(`mean: ${newMean} variance: ${newVar}`);
-    // These came from the the calculated variances from the above commented console log
-    expect(roundTo(newMean, 4 )).toEqual(0.0155);
-    expect(roundTo(newVar, 6)).toEqual(0.000153);
+    expect(roundTo(newMean, 4)).toMatchInlineSnapshot(`0.0155`);
+    expect(roundTo(newVar, 6)).toMatchInlineSnapshot(`0.000153`);
     expect(results).toEqual(bezkrovnyScores as MSSIMValues);
   }, 70000);
-
-
 });

spec/helpers/getJSONScores.ts

@@ -1,15 +1,15 @@
-import { resolve, sep } from "path";
-import { readdirSync } from "fs";
-import { readpixels } from "./readpixels";
+import { resolve, sep } from 'path'
+import { readdirSync } from 'fs'
+import { readpixels } from './readpixels'
 
 export type LoadedData = {
-  file: ImageData;
-  mssim: number;
-  reference: ImageData;
-};
+  file: ImageData
+  mssim: number
+  reference: ImageData
+}
 
-function filterFiles(file = "", extension: string) {
-  return file.toLowerCase().endsWith(extension);
+function filterFiles(file = '', extension: string) {
+  return file.toLowerCase().endsWith(extension)
 }
 
 async function fileToObjectPath(
@@ -18,26 +18,26 @@ async function fileToObjectPath(
   fileName: string,
   extension: string
 ): Promise<{ [key: string]: LoadedData }> {
-  let referenceFile = (fileName.split(sep).pop() || "").split("_")[0] || "";
+  let referenceFile = (fileName.split(sep).pop() || '').split('_')[0] || ''
 
   if (!referenceFile.endsWith(`.${extension}`)) {
-    referenceFile += `.${extension}`;
+    referenceFile += `.${extension}`
   }
 
   if (scores[fileName] === 0) {
-    return {};
+    return {}
   }
 
-  const reference = resolve(path, referenceFile);
-  const file = resolve(path, fileName);
+  const reference = resolve(path, referenceFile)
+  const file = resolve(path, fileName)
 
   return {
     [fileName]: {
       reference: await readpixels(reference),
       file: await readpixels(file),
-      mssim: scores[fileName] || 0
-    }
-  };
+      mssim: scores[fileName] || 0,
+    },
+  }
 }
 
 export async function getJSONScores(
@@ -47,12 +47,12 @@ export async function getJSONScores(
 ) {
   const objects = await Promise.all(
     readdirSync(path)
-      .filter(file => filterFiles(file, extension))
-      .map(fileName => fileToObjectPath(scores, path, fileName, extension))
-  );
+      .filter((file) => filterFiles(file, extension))
+      .map((fileName) => fileToObjectPath(scores, path, fileName, extension))
+  )
 
   return objects.reduce(
     (acc, curr) => ({ ...acc, ...curr }),
     {} as { [key: string]: LoadedData }
-  );
+  )
 }

spec/helpers/matrices.ts

@@ -1,20 +1,20 @@
-import imageSamples from "./imageSamples.json";
-import { loadCsv } from "./sampleloader";
-import { flatMxToData } from "./util";
+import imageSamples from './imageSamples.json'
+import { loadCsv } from './sampleloader'
+import { flatMxToData } from './util'
 
 const sampleCsv = loadCsv({
-  lena: "./samples/lena/q1.csv",
-  lena02876: "./samples/lena/q02876.csv"
-});
-const samples = JSON.parse(JSON.stringify(imageSamples));
+  lena: './samples/lena/q1.csv',
+  lena02876: './samples/lena/q02876.csv',
+})
+const samples = JSON.parse(JSON.stringify(imageSamples))
 
-Object.keys(samples).forEach(key => {
-  Object.keys(samples[key]).forEach(skey => {
-    samples[key][skey] = flatMxToData(samples[key][skey]);
-  });
-});
-Object.keys(sampleCsv).forEach(key => {
-  sampleCsv[key] = flatMxToData(sampleCsv[key]);
-});
+Object.keys(samples).forEach((key) => {
+  Object.keys(samples[key]).forEach((skey) => {
+    samples[key][skey] = flatMxToData(samples[key][skey])
+  })
+})
+Object.keys(sampleCsv).forEach((key) => {
+  sampleCsv[key] = flatMxToData(sampleCsv[key])
+})
 
-export { samples, sampleCsv };
+export { samples, sampleCsv }

spec/helpers/measure.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-console */
-import Benchmark from "benchmark";
+import Benchmark from 'benchmark'
 
 export function measure(
   expect: jest.Expect,
@@ -8,67 +8,67 @@ export function measure(
   fast,
   slow
 ) {
-  const results = {};
+  const results = {}
   const suite = new Benchmark.Suite(testName, {
     defer,
     onError,
     async: defer,
     onComplete,
-    onCycle
-  });
+    onCycle,
+  })
 
   suite.add(fast.name, {
     defer,
-    fn: fast.fn
-  });
+    fn: fast.fn,
+  })
 
   suite.add(slow.name, {
     defer,
-    fn: slow.fn
-  });
+    fn: slow.fn,
+  })
 
   suite.run({
     defer,
-    async: defer
-  });
+    async: defer,
+  })
 
   function onComplete() {
-    const fastest = this.filter("fastest").map("name");
-    const slowest = this.filter("slowest").map("name");
+    const fastest = this.filter('fastest').map('name')
+    const slowest = this.filter('slowest').map('name')
 
-    Object.keys(results).forEach(name => {
-      const { rme, hz } = results[name];
-      let icon = "";
+    Object.keys(results).forEach((name) => {
+      const { rme, hz } = results[name]
+      let icon = ''
 
       if (fastest.includes(name)) {
-        icon = "🏍";
+        icon = '🏍'
       } else if (slowest.includes(name)) {
-        icon = "🐌";
+        icon = '🐌'
       }
-      console.log(`  - ${name}: ${hz} ops/sec ±${rme}% ${icon}`);
-    });
+      console.log(`  - ${name}: ${hz} ops/sec ±${rme}% ${icon}`)
+    })
 
-    let success;
+    let success
     if (fastest.includes(fast.name) && slowest.includes(slow.name)) {
-      success = true;
+      success = true
     } else if (fastest.includes(fast.name) && fastest.includes(slow.name)) {
-      success = true;
+      success = true
     } else {
-      success = false;
+      success = false
     }
-    expect(success).toBe(true);
+    expect(success).toBe(true)
   }
 
   function onCycle({ target }) {
     results[target.name] = {
       rme: Math.round(target.stats.rme),
       count: target.count,
-      hz: target.hz.toFixed(2)
-    };
+      hz: target.hz.toFixed(2),
+    }
   }
 
   function onError() {
-    const success = false;
-    expect(success).toBe(true);
+    const success = false
+    expect(success).toBe(true)
   }
 }