@trishchuk/coolors-mcp 1.0.0

package/src/color/quantize/__tests__/quantizer_celebi.test.ts

@@ -0,0 +1,195 @@
+/**
+ * Tests for Celebi quantizer
+ */
+
+import { describe, expect, it } from "vitest";
+
+import * as utils from "../../utils/color_utils";
+import { QuantizerCelebi } from "../quantizer_celebi";
+
+describe("QuantizerCelebi", () => {
+  it("should quantize a single color", () => {
+    const pixels = [
+      utils.argbFromRgb(255, 0, 0),
+      utils.argbFromRgb(255, 0, 0),
+      utils.argbFromRgb(255, 0, 0),
+    ];
+
+    const result = QuantizerCelebi.quantize(pixels, 1);
+
+    expect(result.size).toBe(1);
+    // Should have red color
+    const colors = Array.from(result.keys());
+    const rgb = {
+      b: utils.blueFromArgb(colors[0]),
+      g: utils.greenFromArgb(colors[0]),
+      r: utils.redFromArgb(colors[0]),
+    };
+
+    // Should be close to red
+    expect(rgb.r).toBeGreaterThan(250);
+    expect(rgb.g).toBeLessThan(5);
+    expect(rgb.b).toBeLessThan(5);
+
+    // Population should be 3
+    expect(result.get(colors[0])).toBe(3);
+  });
+
+  it("should quantize multiple distinct colors", () => {
+    const pixels = [
+      utils.argbFromRgb(255, 0, 0), // Red
+      utils.argbFromRgb(0, 255, 0), // Green
+      utils.argbFromRgb(0, 0, 255), // Blue
+      utils.argbFromRgb(255, 255, 0), // Yellow
+    ];
+
+    const result = QuantizerCelebi.quantize(pixels, 4);
+
+    // Should preserve distinct colors when maxColors is sufficient
+    expect(result.size).toBeLessThanOrEqual(4);
+    expect(result.size).toBeGreaterThan(0);
+
+    // Check total population
+    let totalPopulation = 0;
+    for (const pop of result.values()) {
+      totalPopulation += pop;
+    }
+    expect(totalPopulation).toBe(4);
+  });
+
+  it("should reduce colors when maxColors is limited", () => {
+    const pixels = [
+      utils.argbFromRgb(255, 0, 0),
+      utils.argbFromRgb(254, 0, 0), // Very similar to red
+      utils.argbFromRgb(0, 255, 0),
+      utils.argbFromRgb(0, 254, 0), // Very similar to green
+      utils.argbFromRgb(0, 0, 255),
+      utils.argbFromRgb(0, 0, 254), // Very similar to blue
+    ];
+
+    const result = QuantizerCelebi.quantize(pixels, 3);
+
+    // Should reduce to approximately 3 colors
+    expect(result.size).toBeLessThanOrEqual(3);
+    expect(result.size).toBeGreaterThan(0);
+  });
+
+  it("should handle grayscale colors", () => {
+    const pixels = [
+      utils.argbFromRgb(0, 0, 0), // Black
+      utils.argbFromRgb(128, 128, 128), // Gray
+      utils.argbFromRgb(255, 255, 255), // White
+    ];
+
+    const result = QuantizerCelebi.quantize(pixels, 3);
+
+    expect(result.size).toBeLessThanOrEqual(3);
+    expect(result.size).toBeGreaterThan(0);
+
+    // Total population should be preserved
+    let totalPopulation = 0;
+    for (const pop of result.values()) {
+      totalPopulation += pop;
+    }
+    expect(totalPopulation).toBe(3);
+  });
+
+  it("should handle empty pixel array", () => {
+    const result = QuantizerCelebi.quantize([], 10);
+
+    expect(result.size).toBe(0);
+  });
+
+  it("should handle single pixel", () => {
+    const pixel = utils.argbFromRgb(123, 45, 67);
+    const result = QuantizerCelebi.quantize([pixel], 10);
+
+    expect(result.size).toBe(1);
+    expect(result.has(pixel)).toBe(true);
+    expect(result.get(pixel)).toBe(1);
+  });
+
+  it("should handle maxColors of 1", () => {
+    const pixels = [
+      utils.argbFromRgb(255, 0, 0),
+      utils.argbFromRgb(0, 255, 0),
+      utils.argbFromRgb(0, 0, 255),
+    ];
+
+    const result = QuantizerCelebi.quantize(pixels, 1);
+
+    expect(result.size).toBe(1);
+
+    // Population should be total
+    const population = Array.from(result.values())[0];
+    expect(population).toBe(3);
+  });
+
+  it("should handle large number of similar colors", () => {
+    const pixels: number[] = [];
+
+    // Add many similar shades of blue
+    for (let i = 0; i < 100; i++) {
+      const variation = Math.floor(i / 10);
+      pixels.push(utils.argbFromRgb(0, 0, 200 + variation));
+    }
+
+    const result = QuantizerCelebi.quantize(pixels, 5);
+
+    // Should reduce to fewer colors
+    expect(result.size).toBeLessThanOrEqual(5);
+    expect(result.size).toBeGreaterThan(0);
+
+    // Total population should be preserved
+    let totalPopulation = 0;
+    for (const pop of result.values()) {
+      totalPopulation += pop;
+    }
+    expect(totalPopulation).toBe(100);
+  });
+
+  it("should produce consistent results for same input", () => {
+    const pixels = [
+      utils.argbFromRgb(100, 150, 200),
+      utils.argbFromRgb(150, 100, 200),
+      utils.argbFromRgb(200, 100, 150),
+    ];
+
+    const result1 = QuantizerCelebi.quantize(pixels, 2);
+    const result2 = QuantizerCelebi.quantize(pixels, 2);
+
+    // Results should be deterministic
+    expect(result1.size).toBe(result2.size);
+
+    // Check that the same colors are produced
+    const colors1 = Array.from(result1.keys()).sort();
+    const colors2 = Array.from(result2.keys()).sort();
+
+    expect(colors1).toEqual(colors2);
+  });
+
+  it("should handle gradient properly", () => {
+    const pixels: number[] = [];
+
+    // Create a gradient from red to blue
+    for (let i = 0; i < 100; i++) {
+      const r = Math.floor(255 * (1 - i / 100));
+      const b = Math.floor(255 * (i / 100));
+      pixels.push(utils.argbFromRgb(r, 0, b));
+    }
+
+    const result = QuantizerCelebi.quantize(pixels, 10);
+
+    // Should extract representative colors from gradient
+    expect(result.size).toBeLessThanOrEqual(10);
+    expect(result.size).toBeGreaterThan(1); // Should find multiple colors
+
+    // Check that we have both reddish and bluish colors
+    const colors = Array.from(result.keys());
+    const hasReddish = colors.some((c) => utils.redFromArgb(c) > 200);
+    const hasBluish = colors.some((c) => utils.blueFromArgb(c) > 200);
+
+    expect(hasReddish).toBe(true);
+    expect(hasBluish).toBe(true);
+  });
+});

package/src/color/quantize/lab_point_provider.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as utils from "../utils/color_utils.js";
+import { PointProvider } from "./point_provider.js";
+
+/**
+ * Provides conversions needed for K-Means quantization. Converting input to
+ * points, and converting the final state of the K-Means algorithm to colors.
+ */
+export class LabPointProvider implements PointProvider {
+  /**
+   * Standard CIE 1976 delta E formula also takes the square root, unneeded
+   * here. This method is used by quantization algorithms to compare distance,
+   * and the relative ordering is the same, with or without a square root.
+   *
+   * This relatively minor optimization is helpful because this method is
+   * called at least once for each pixel in an image.
+   */
+  distance(from: number[], to: number[]): number {
+    const dL = from[0] - to[0];
+    const dA = from[1] - to[1];
+    const dB = from[2] - to[2];
+    return dL * dL + dA * dA + dB * dB;
+  }
+
+  /**
+   * Convert a color represented in ARGB to a 3-element array of L*a*b*
+   * coordinates of the color.
+   */
+  fromInt(argb: number): number[] {
+    return utils.labFromArgb(argb);
+  }
+
+  /**
+   * Convert a 3-element array to a color represented in ARGB.
+   */
+  toInt(point: number[]): number {
+    return utils.argbFromLab(point[0], point[1], point[2]);
+  }
+}

package/src/color/quantize/point_provider.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * An interface to allow use of different color spaces by
+ * quantizers.
+ */
+
+export declare interface PointProvider {
+  distance(from: number[], to: number[]): number;
+  fromInt(argb: number): number[];
+  toInt(point: number[]): number;
+}

package/src/color/quantize/quantizer_celebi.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { QuantizerWsmeans } from "./quantizer_wsmeans.js";
+import { QuantizerWu } from "./quantizer_wu.js";
+
+/**
+ * An image quantizer that improves on the quality of a standard K-Means
+ * algorithm by setting the K-Means initial state to the output of a Wu
+ * quantizer, instead of random centroids. Improves on speed by several
+ * optimizations, as implemented in Wsmeans, or Weighted Square Means, K-Means
+ * with those optimizations.
+ *
+ * This algorithm was designed by M. Emre Celebi, and was found in their 2011
+ * paper, Improving the Performance of K-Means for Color Quantization.
+ * https://arxiv.org/abs/1101.0395
+ */
+// material_color_utilities is designed to have a consistent API across
+// platforms and modular components that can be moved around easily. Using a
+// class as a namespace facilitates this.
+//
+// tslint:disable-next-line:class-as-namespace
+export class QuantizerCelebi {
+  /**
+   * @param pixels Colors in ARGB format.
+   * @param maxColors The number of colors to divide the image into. A lower
+   *     number of colors may be returned.
+   * @return Map with keys of colors in ARGB format, and values of number of
+   *     pixels in the original image that correspond to the color in the
+   *     quantized image.
+   */
+  static quantize(pixels: number[], maxColors: number): Map<number, number> {
+    const wu = new QuantizerWu();
+    const wuResult = wu.quantize(pixels, maxColors);
+    return QuantizerWsmeans.quantize(pixels, wuResult, maxColors);
+  }
+}

package/src/color/quantize/quantizer_celebi_test.ts

@@ -0,0 +1,71 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import "jasmine";
+
+import { QuantizerCelebi } from "./quantizer_celebi.js";
+
+const RED = 0xffff0000;
+const GREEN = 0xff00ff00;
+const BLUE = 0xff0000ff;
+
+describe("QuantizerCelebi", () => {
+  it("1R", () => {
+    const answer = QuantizerCelebi.quantize([RED], 128);
+    expect(answer.size).toBe(1);
+    expect(answer.get(RED)).toBe(1);
+  });
+
+  it("1G", () => {
+    const answer = QuantizerCelebi.quantize([GREEN], 128);
+    expect(answer.size).toBe(1);
+    expect(answer.get(GREEN)).toBe(1);
+  });
+
+  it("1B", () => {
+    const answer = QuantizerCelebi.quantize([BLUE], 128);
+    expect(answer.size).toBe(1);
+    expect(answer.get(BLUE)).toBe(1);
+  });
+
+  it("5B", () => {
+    const answer = QuantizerCelebi.quantize(
+      [BLUE, BLUE, BLUE, BLUE, BLUE],
+      128,
+    );
+    expect(answer.size).toBe(1);
+    expect(answer.get(BLUE)).toBe(5);
+  });
+
+  it("2R 3G", () => {
+    const answer = QuantizerCelebi.quantize(
+      [RED, RED, GREEN, GREEN, GREEN],
+      128,
+    );
+    expect(answer.size).toBe(2);
+    expect(answer.get(RED)).toBe(2);
+    expect(answer.get(GREEN)).toBe(3);
+  });
+
+  it("1R 1G 1B", () => {
+    const answer = QuantizerCelebi.quantize([RED, GREEN, BLUE], 128);
+    expect(answer.size).toBe(3);
+    expect(answer.get(RED)).toBe(1);
+    expect(answer.get(GREEN)).toBe(1);
+    expect(answer.get(BLUE)).toBe(1);
+  });
+});

package/src/color/quantize/quantizer_map.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as utils from "../utils/color_utils.js";
+
+/**
+ * Quantizes an image into a map, with keys of ARGB colors, and values of the
+ * number of times that color appears in the image.
+ */
+// material_color_utilities is designed to have a consistent API across
+// platforms and modular components that can be moved around easily. Using a
+// class as a namespace facilitates this.
+//
+// tslint:disable-next-line:class-as-namespace
+export class QuantizerMap {
+  /**
+   * @param pixels Colors in ARGB format.
+   * @return A Map with keys of ARGB colors, and values of the number of times
+   *     the color appears in the image.
+   */
+  static quantize(pixels: number[]): Map<number, number> {
+    const countByColor = new Map<number, number>();
+    for (let i = 0; i < pixels.length; i++) {
+      const pixel = pixels[i];
+      const alpha = utils.alphaFromArgb(pixel);
+      if (alpha < 255) {
+        continue;
+      }
+      countByColor.set(pixel, (countByColor.get(pixel) ?? 0) + 1);
+    }
+    return countByColor;
+  }
+}

package/src/color/quantize/quantizer_wsmeans.ts

@@ -0,0 +1,232 @@
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { LabPointProvider } from "./lab_point_provider.js";
+
+const MAX_ITERATIONS = 10;
+const MIN_MOVEMENT_DISTANCE = 3.0;
+
+/**
+ *  A wrapper for maintaining a table of distances between K-Means clusters.
+ */
+class DistanceAndIndex {
+  distance: number = -1;
+  index: number = -1;
+}
+
+/**
+ * An image quantizer that improves on the speed of a standard K-Means algorithm
+ * by implementing several optimizations, including deduping identical pixels
+ * and a triangle inequality rule that reduces the number of comparisons needed
+ * to identify which cluster a point should be moved to.
+ *
+ * Wsmeans stands for Weighted Square Means.
+ *
+ * This algorithm was designed by M. Emre Celebi, and was found in their 2011
+ * paper, Improving the Performance of K-Means for Color Quantization.
+ * https://arxiv.org/abs/1101.0395
+ */
+// material_color_utilities is designed to have a consistent API across
+// platforms and modular components that can be moved around easily. Using a
+// class as a namespace facilitates this.
+//
+// tslint:disable-next-line:class-as-namespace
+export class QuantizerWsmeans {
+  /**
+   * @param inputPixels Colors in ARGB format.
+   * @param startingClusters Defines the initial state of the quantizer. Passing
+   *     an empty array is fine, the implementation will create its own initial
+   *     state that leads to reproducible results for the same inputs.
+   *     Passing an array that is the result of Wu quantization leads to higher
+   *     quality results.
+   * @param maxColors The number of colors to divide the image into. A lower
+   *     number of colors may be returned.
+   * @return Colors in ARGB format.
+   */
+  static quantize(
+    inputPixels: number[],
+    startingClusters: number[],
+    maxColors: number,
+  ): Map<number, number> {
+    const pixelToCount = new Map<number, number>();
+    const points = new Array<number[]>();
+    const pixels = new Array<number>();
+    const pointProvider = new LabPointProvider();
+    let pointCount = 0;
+    for (let i = 0; i < inputPixels.length; i++) {
+      const inputPixel = inputPixels[i];
+      const pixelCount = pixelToCount.get(inputPixel);
+      if (pixelCount === undefined) {
+        pointCount++;
+        points.push(pointProvider.fromInt(inputPixel));
+        pixels.push(inputPixel);
+        pixelToCount.set(inputPixel, 1);
+      } else {
+        pixelToCount.set(inputPixel, pixelCount + 1);
+      }
+    }
+
+    const counts = new Array<number>();
+    for (let i = 0; i < pointCount; i++) {
+      const pixel = pixels[i];
+      const count = pixelToCount.get(pixel);
+      if (count !== undefined) {
+        counts[i] = count;
+      }
+    }
+
+    let clusterCount = Math.min(maxColors, pointCount);
+    if (startingClusters.length > 0) {
+      clusterCount = Math.min(clusterCount, startingClusters.length);
+    }
+
+    const clusters = new Array<number[]>();
+    for (let i = 0; i < startingClusters.length; i++) {
+      clusters.push(pointProvider.fromInt(startingClusters[i]));
+    }
+    const additionalClustersNeeded = clusterCount - clusters.length;
+    if (startingClusters.length === 0 && additionalClustersNeeded > 0) {
+      for (let i = 0; i < additionalClustersNeeded; i++) {
+        const l = Math.random() * 100.0;
+        const a = Math.random() * (100.0 - -100.0 + 1) + -100;
+        const b = Math.random() * (100.0 - -100.0 + 1) + -100;
+
+        clusters.push([l, a, b]);
+      }
+    }
+
+    const clusterIndices = new Array<number>();
+    for (let i = 0; i < pointCount; i++) {
+      clusterIndices.push(Math.floor(Math.random() * clusterCount));
+    }
+
+    const indexMatrix = new Array<number[]>();
+    for (let i = 0; i < clusterCount; i++) {
+      indexMatrix.push(new Array<number>());
+      for (let j = 0; j < clusterCount; j++) {
+        indexMatrix[i].push(0);
+      }
+    }
+
+    const distanceToIndexMatrix = new Array<DistanceAndIndex[]>();
+    for (let i = 0; i < clusterCount; i++) {
+      distanceToIndexMatrix.push(new Array<DistanceAndIndex>());
+      for (let j = 0; j < clusterCount; j++) {
+        distanceToIndexMatrix[i].push(new DistanceAndIndex());
+      }
+    }
+
+    const pixelCountSums = new Array<number>();
+    for (let i = 0; i < clusterCount; i++) {
+      pixelCountSums.push(0);
+    }
+    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+      for (let i = 0; i < clusterCount; i++) {
+        for (let j = i + 1; j < clusterCount; j++) {
+          const distance = pointProvider.distance(clusters[i], clusters[j]);
+          distanceToIndexMatrix[j][i].distance = distance;
+          distanceToIndexMatrix[j][i].index = i;
+          distanceToIndexMatrix[i][j].distance = distance;
+          distanceToIndexMatrix[i][j].index = j;
+        }
+        distanceToIndexMatrix[i].sort();
+        for (let j = 0; j < clusterCount; j++) {
+          indexMatrix[i][j] = distanceToIndexMatrix[i][j].index;
+        }
+      }
+
+      let pointsMoved = 0;
+      for (let i = 0; i < pointCount; i++) {
+        const point = points[i];
+        const previousClusterIndex = clusterIndices[i];
+        const previousCluster = clusters[previousClusterIndex];
+        const previousDistance = pointProvider.distance(point, previousCluster);
+        let minimumDistance = previousDistance;
+        let newClusterIndex = -1;
+        for (let j = 0; j < clusterCount; j++) {
+          if (
+            distanceToIndexMatrix[previousClusterIndex][j].distance >=
+            4 * previousDistance
+          ) {
+            continue;
+          }
+          const distance = pointProvider.distance(point, clusters[j]);
+          if (distance < minimumDistance) {
+            minimumDistance = distance;
+            newClusterIndex = j;
+          }
+        }
+        if (newClusterIndex !== -1) {
+          const distanceChange = Math.abs(
+            Math.sqrt(minimumDistance) - Math.sqrt(previousDistance),
+          );
+          if (distanceChange > MIN_MOVEMENT_DISTANCE) {
+            pointsMoved++;
+            clusterIndices[i] = newClusterIndex;
+          }
+        }
+      }
+
+      if (pointsMoved === 0 && iteration !== 0) {
+        break;
+      }
+
+      const componentASums = new Array<number>(clusterCount).fill(0);
+      const componentBSums = new Array<number>(clusterCount).fill(0);
+      const componentCSums = new Array<number>(clusterCount).fill(0);
+
+      for (let i = 0; i < clusterCount; i++) {
+        pixelCountSums[i] = 0;
+      }
+      for (let i = 0; i < pointCount; i++) {
+        const clusterIndex = clusterIndices[i];
+        const point = points[i];
+        const count = counts[i];
+        pixelCountSums[clusterIndex] += count;
+        componentASums[clusterIndex] += point[0] * count;
+        componentBSums[clusterIndex] += point[1] * count;
+        componentCSums[clusterIndex] += point[2] * count;
+      }
+
+      for (let i = 0; i < clusterCount; i++) {
+        const count = pixelCountSums[i];
+        if (count === 0) {
+          clusters[i] = [0.0, 0.0, 0.0];
+          continue;
+        }
+        const a = componentASums[i] / count;
+        const b = componentBSums[i] / count;
+        const c = componentCSums[i] / count;
+        clusters[i] = [a, b, c];
+      }
+    }
+
+    const argbToPopulation = new Map<number, number>();
+    for (let i = 0; i < clusterCount; i++) {
+      const count = pixelCountSums[i];
+      if (count === 0) {
+        continue;
+      }
+
+      const possibleNewCluster = pointProvider.toInt(clusters[i]);
+      // Accumulate population counts when multiple clusters converge to same color
+      const existingCount = argbToPopulation.get(possibleNewCluster) || 0;
+      argbToPopulation.set(possibleNewCluster, existingCount + count);
+    }
+    return argbToPopulation;
+  }
+}