new build system

Author: T-Dynamos

.github/workflows/cibuildwheel.yml

@@ -34,13 +34,11 @@ jobs:
         CIBW_BEFORE_TEST: >
           pip install -r {project}/requirements.txt -r {project}/requirements-dev.txt
         CIBW_TEST_COMMAND: >
-          curl -L -o test_image.jpg "https://raw.githubusercontent.com/mohammadimtiazz/standard-test-images-for-Image-Processing/refs/heads/master/standard_test_images/tulips.png" &&
+          python -c "from PIL import Image; Image.new('RGB', (128, 128), (70, 120, 180)).save('test_image.jpg')" &&
           python {project}/tests/test_all.py --image test_image.jpg --quality 1 --method pillow --tonal-spot &&
           python {project}/tests/test_all.py --image test_image.jpg --quality 1 --method cpp --tonal-spot
         CIBW_BEFORE_BUILD: >
-          pip install setuptools wheel
-        CIBW_ENVIRONMENT: >
-          PURE_PYTHON=False
+          pip install -U pip setuptools wheel pybind11
 
     - uses: actions/upload-artifact@v4
       with:

.gitignore

@@ -1,9 +1,13 @@
-build
-patch
-dist 
-*.egg* 
-materialyoucolor/quantize
-__pycache__
+build/
+dist/
+*.egg*
+*.whl
+*.so
+*.pyd
+
+__pycache__/
 *.pyc
+
 image.jpg
+test_image.jpg
 tests/compare*

README.md

@@ -84,7 +84,7 @@ Thanks :heart: to [@midn8hustlr](https://github.com/midn8hustlr) for this [AUR p
 
 Ensure these lines in `buildozer.spec`:
 ```python
-requirements = materialyoucolor==3.0.0
+requirements = materialyoucolor==3.0.2
 p4a.branch = develop
 ```
 

materialyoucolor/__init__.py

@@ -1 +1 @@
-__version__ = "3.0.1"
+__version__ = "3.0.2"

materialyoucolor/quantize/__init__.py

@@ -0,0 +1 @@
+from .celebi import QuantizeCelebi, ImageQuantizeCelebi

materialyoucolor/quantize/celebi.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2022 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.
+ */
+
+#include "celebi.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <iostream>
+#include <vector>
+
+#include "wsmeans.h"
+#include "wu.h"
+#include "utils.h"
+#include "pybind11/pybind11.h"
+#include "pybind11/stl.h"
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+namespace python = pybind11;
+
+// std::map<Argb, uint32_t>
+std::map<uint32_t, uint32_t> QuantizeCelebi(const std::vector<std::vector<int>>& pixels,
+                               int max_colors) {
+  if (max_colors > 256) {
+    max_colors = 256;
+  }
+  int pixel_count = pixels.size();
+
+  std::vector<material_color_utilities::Argb> opaque_pixels;
+  opaque_pixels.reserve(pixel_count);
+  for (int i = 0; i < pixel_count; i++) {
+    uint32_t pixel = (pixels[i][0] << 16) | 
+                     (pixels[i][1] << 8) | 
+                     (pixels[i][2]);
+    //if (pixels[i].size() > 3 && pixels[i][3] == 255) 
+    opaque_pixels.push_back(pixel);
+  }
+
+  std::vector<material_color_utilities::Argb> wu_result = material_color_utilities::QuantizeWu(
+      opaque_pixels, max_colors);
+
+  material_color_utilities::QuantizerResult result =
+      material_color_utilities::QuantizeWsmeans(opaque_pixels, wu_result, max_colors);
+  
+  return result.color_to_count;
+}
+
+
+std::map<uint32_t, uint32_t>  ImageQuantizeCelebi(const char* image_path, const int quality,  int max_colors) {
+    int width, height, channels;
+    std::vector<std::vector<int>> pixel_array = {};
+    unsigned char* pixel_result = stbi_load(image_path, &width, &height, &channels, 4);
+    if (!pixel_result) {return QuantizeCelebi(pixel_array, max_colors);}
+    pixel_array.reserve( (width * height) / quality );
+    unsigned char* pixel_position;
+    int _quality = quality;
+    for (int y = 0; y < height; ++y) {
+        for (int x = 0; x < width; x = x+_quality) {
+            pixel_position = pixel_result + (x + y * width) * 4;
+            std::vector<int> current_color = {
+              pixel_position[0], pixel_position[1], pixel_position[2]};
+            if (channels > 3) {current_color.push_back(pixel_position[3]);}  
+            pixel_array.push_back(current_color);
+            if (_quality < quality) {_quality = quality;}
+        }
+        if (y % 2 == 0) {
+          _quality = quality / 2;
+        } else {_quality = quality;}
+    }
+    stbi_image_free(pixel_result);
+    return QuantizeCelebi(pixel_array, max_colors);
+}
+
+
+PYBIND11_MODULE(celebi, m) {
+    m.doc() = "Functions from cpp backend";
+    m.def("QuantizeCelebi", &QuantizeCelebi, "Get dominant colors");
+    m.def("ImageQuantizeCelebi", &ImageQuantizeCelebi, "Get pixel array");
+}

materialyoucolor/quantize/celebi.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 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.
+ */
+
+#ifndef CPP_QUANTIZE_CELEBI_H_
+#define CPP_QUANTIZE_CELEBI_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <vector>
+
+#include "wsmeans.h"
+#include "utils.h"
+
+namespace material_color_utilities {
+
+QuantizerResult QuantizeCelebi(const std::vector<Argb>& pixels,
+                               uint16_t max_colors);
+
+}  // namespace material_color_utilities
+
+#endif  // CPP_QUANTIZE_CELEBI_H_

materialyoucolor/quantize/lab.cc

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2022 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.
+ */
+
+#include "lab.h"
+
+#include <math.h>
+
+#include "utils.h"
+
+namespace material_color_utilities {
+
+Argb IntFromLab(const Lab lab) {
+  double e = 216.0 / 24389.0;
+  double kappa = 24389.0 / 27.0;
+  double ke = 8.0;
+
+  double fy = (lab.l + 16.0) / 116.0;
+  double fx = (lab.a / 500.0) + fy;
+  double fz = fy - (lab.b / 200.0);
+  double fx3 = fx * fx * fx;
+  double x_normalized = (fx3 > e) ? fx3 : (116.0 * fx - 16.0) / kappa;
+  double y_normalized = (lab.l > ke) ? fy * fy * fy : (lab.l / kappa);
+  double fz3 = fz * fz * fz;
+  double z_normalized = (fz3 > e) ? fz3 : (116.0 * fz - 16.0) / kappa;
+  double x = x_normalized * kWhitePointD65[0];
+  double y = y_normalized * kWhitePointD65[1];
+  double z = z_normalized * kWhitePointD65[2];
+
+  // intFromXyz
+  double rL = 3.2406 * x - 1.5372 * y - 0.4986 * z;
+  double gL = -0.9689 * x + 1.8758 * y + 0.0415 * z;
+  double bL = 0.0557 * x - 0.2040 * y + 1.0570 * z;
+
+  int red = Delinearized(rL);
+  int green = Delinearized(gL);
+  int blue = Delinearized(bL);
+
+  return ArgbFromRgb(red, green, blue);
+}
+
+Lab LabFromInt(const Argb argb) {
+  int red = (argb & 0x00ff0000) >> 16;
+  int green = (argb & 0x0000ff00) >> 8;
+  int blue = (argb & 0x000000ff);
+  double red_l = Linearized(red);
+  double green_l = Linearized(green);
+  double blue_l = Linearized(blue);
+  double x = 0.41233895 * red_l + 0.35762064 * green_l + 0.18051042 * blue_l;
+  double y = 0.2126 * red_l + 0.7152 * green_l + 0.0722 * blue_l;
+  double z = 0.01932141 * red_l + 0.11916382 * green_l + 0.95034478 * blue_l;
+  double y_normalized = y / kWhitePointD65[1];
+  double e = 216.0 / 24389.0;
+  double kappa = 24389.0 / 27.0;
+  double fy;
+  if (y_normalized > e) {
+    fy = pow(y_normalized, 1.0 / 3.0);
+  } else {
+    fy = (kappa * y_normalized + 16) / 116;
+  }
+
+  double x_normalized = x / kWhitePointD65[0];
+  double fx;
+  if (x_normalized > e) {
+    fx = pow(x_normalized, 1.0 / 3.0);
+  } else {
+    fx = (kappa * x_normalized + 16) / 116;
+  }
+
+  double z_normalized = z / kWhitePointD65[2];
+  double fz;
+  if (z_normalized > e) {
+    fz = pow(z_normalized, 1.0 / 3.0);
+  } else {
+    fz = (kappa * z_normalized + 16) / 116;
+  }
+
+  double l = 116.0 * fy - 16;
+  double a = 500.0 * (fx - fy);
+  double b = 200.0 * (fy - fz);
+  return {l, a, b};
+}
+
+}  // namespace material_color_utilities

materialyoucolor/quantize/lab.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.
+ */
+
+#ifndef CPP_QUANTIZE_LAB_H_
+#define CPP_QUANTIZE_LAB_H_
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <map>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "utils.h"
+
+namespace material_color_utilities {
+
+struct Lab {
+  double l = 0.0;
+  double a = 0.0;
+  double b = 0.0;
+
+  double DeltaE(const Lab& lab) {
+    double d_l = l - lab.l;
+    double d_a = a - lab.a;
+    double d_b = b - lab.b;
+    return (d_l * d_l) + (d_a * d_a) + (d_b * d_b);
+  }
+
+  std::string ToString() {
+    return "Lab: L* " + std::to_string(l) + " a* " + std::to_string(a) +
+           " b* " + std::to_string(b);
+  }
+};
+
+Argb IntFromLab(const Lab lab);
+Lab LabFromInt(const Argb argb);
+
+}  // namespace material_color_utilities
+#endif  // CPP_QUANTIZE_LAB_H_