quantize: add StbLoadImage using stb_image.h

Author: T-Dynamos

.gitignore

@@ -2,7 +2,6 @@ build
 patch
 dist 
 *.egg* 
-materialyoucolor/quantize/*.cc
-materialyoucolor/quantize/*.h
+materialyoucolor/quantize
 __pycache__
 *.pyc

materialyoucolor/__init__.py

@@ -1 +1 @@
-__version__ = "2.0.8"
+__version__ = "2.0.9"

quantizer_cpp.patch

@@ -1,84 +1,3 @@
-diff '--color=auto' -uNr patch/celebi.cc materialyoucolor/quantize/celebi.cc
---- patch/celebi.cc	2024-01-13 11:47:16.897315093 +0530
-+++ materialyoucolor/quantize/celebi.cc	2023-12-29 11:13:04.097468166 +0530
-@@ -14,47 +14,53 @@
-  * limitations under the License.
-  */
- 
--#include "cpp/quantize/celebi.h"
-+#include "celebi.h"
- 
- #include <cstddef>
-+#include <cstdint>
- #include <cstdio>
- #include <cstdlib>
-+#include <iostream>
- #include <vector>
- 
--#include "cpp/quantize/wsmeans.h"
--#include "cpp/quantize/wu.h"
--#include "cpp/utils/utils.h"
--
--namespace material_color_utilities {
--
--QuantizerResult QuantizeCelebi(const std::vector<Argb>& pixels,
--                               uint16_t max_colors) {
--  if (max_colors == 0 || pixels.empty()) {
--    return QuantizerResult();
--  }
--
-+#include "wsmeans.h"
-+#include "wu.h"
-+#include "utils.h"
-+#include "pybind11/pybind11.h"
-+#include "pybind11/stl.h"
-+
-+namespace python = pybind11;
-+
-+// std::map<Argb, uint32_t>
-+std::map<uint32_t, uint32_t> QuantizeCelebi(const python::list& pixels,
-+                               int max_colors) {
-   if (max_colors > 256) {
-     max_colors = 256;
-   }
- 
-   int pixel_count = pixels.size();
- 
--  std::vector<Argb> opaque_pixels;
-+  std::vector<material_color_utilities::Argb> opaque_pixels;
-   opaque_pixels.reserve(pixel_count);
-   for (int i = 0; i < pixel_count; i++) {
--    int pixel = pixels[i];
--    if (!IsOpaque(pixel)) {
--      continue;
--    }
-+    python::list rgba_ = python::cast<python::list>(pixels[i]);
-+    uint32_t pixel = (python::cast<uint32_t>(rgba_[0])  << 16) | 
-+                     (python::cast<uint32_t>(rgba_[1])  << 8) | 
-+                     python::cast<uint32_t>(rgba_[2]);
-     opaque_pixels.push_back(pixel);
-   }
- 
--  std::vector<Argb> wu_result = QuantizeWu(opaque_pixels, max_colors);
--
--  QuantizerResult result =
--      QuantizeWsmeans(opaque_pixels, wu_result, max_colors);
-+  std::vector<material_color_utilities::Argb> wu_result = material_color_utilities::QuantizeWu(opaque_pixels, max_colors);
- 
--  return result;
-+  material_color_utilities::QuantizerResult result =
-+      material_color_utilities::QuantizeWsmeans(opaque_pixels, wu_result, max_colors);
-+  
-+  return result.color_to_count;
- }
- 
--}  // namespace material_color_utilities
-+
-+
-+PYBIND11_MODULE(celebi, m) {
-+    m.doc() = "QuantizeCelebi from cpp";
-+    m.def("QuantizeCelebi", &QuantizeCelebi, "Get dominant colors");
-+}
 diff '--color=auto' -uNr patch/celebi.h materialyoucolor/quantize/celebi.h
 --- patch/celebi.h	2024-01-13 11:47:16.477314056 +0530
 +++ materialyoucolor/quantize/celebi.h	2023-12-29 11:08:43.363374804 +0530
@@ -252,3 +171,108 @@ diff '--color=auto' -uNr patch/wu.h materialyoucolor/quantize/wu.h
 
  namespace material_color_utilities {
 
+--- patch/celebi.cc	2024-03-25 23:22:50.123427023 +0530
++++ materialyoucolor/quantize/celebi.cc	2024-03-25 23:20:03.277959473 +0530
+@@ -14,47 +14,78 @@
+  * limitations under the License.
+  */
+ 
+-#include "cpp/quantize/celebi.h"
++#include "celebi.h"
+ 
+ #include <cstddef>
++#include <cstdint>
+ #include <cstdio>
+ #include <cstdlib>
++#include <iostream>
+ #include <vector>
+ 
+-#include "cpp/quantize/wsmeans.h"
+-#include "cpp/quantize/wu.h"
+-#include "cpp/utils/utils.h"
+-
+-namespace material_color_utilities {
+-
+-QuantizerResult QuantizeCelebi(const std::vector<Argb>& pixels,
+-                               uint16_t max_colors) {
+-  if (max_colors == 0 || pixels.empty()) {
+-    return QuantizerResult();
+-  }
+-
++#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<Argb> opaque_pixels;
++  std::vector<material_color_utilities::Argb> opaque_pixels;
+   opaque_pixels.reserve(pixel_count);
+   for (int i = 0; i < pixel_count; i++) {
+-    int pixel = pixels[i];
+-    if (!IsOpaque(pixel)) {
+-      continue;
+-    }
++    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<Argb> wu_result = QuantizeWu(opaque_pixels, max_colors);
++  std::vector<material_color_utilities::Argb> wu_result = material_color_utilities::QuantizeWu(
++      opaque_pixels, max_colors);
+ 
+-  QuantizerResult result =
+-      QuantizeWsmeans(opaque_pixels, wu_result, max_colors);
++  material_color_utilities::QuantizerResult result =
++      material_color_utilities::QuantizeWsmeans(opaque_pixels, wu_result, max_colors);
++  
++  return result.color_to_count;
++}
++ 
+ 
+-  return result;
++std::vector<std::vector<int>> StbLoadImage(const char* image_path) {
++    int width, height, channels;
++    std::vector<std::vector<int>> pixel_array = {};
++    // Load the actual image
++    unsigned char* pixel_result = stbi_load(image_path, &width, &height, &channels, 4);
++    if (!pixel_result) {return pixel_array;}
++
++    pixel_array.reserve(width * height);
++    unsigned char* pixel_position;
++    
++    for (int y = 0; y < height; ++y) {
++        for (int x = 0; x < width; ++x) {
++            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);
++        }
++    }
++    stbi_image_free(pixel_result);
++    return pixel_array;
+ }
+ 
+-}  // namespace material_color_utilities
++PYBIND11_MODULE(celebi, m) {
++    m.doc() = "Functions from cpp backend";
++    m.def("QuantizeCelebi", &QuantizeCelebi, "Get dominant colors");
++    m.def("StbLoadImage", &StbLoadImage, "Get pixel array");
++}

setup.py

@@ -614,6 +614,13 @@ def download_files(base_url, folder, file_map):
     "stl/filesystem.h",
 }
 
+# For stb_image backend
+STB_IMAGE_COMMIT = "ae721c50eaf761660b4f90cc590453cdb0c2acd0"
+STB_IMAGE_URL = (
+    "https://raw.githubusercontent.com/nothings"
+    "/stb/{}/".format(STB_IMAGE_COMMIT)
+)
+
 if PURE_PYTHON:
     print(
         "\nWarning: Skipping build of extension : `QuantizeCelebi`"
@@ -624,6 +631,13 @@ def download_files(base_url, folder, file_map):
     should_apply = download_files(MCU_URL, MCU_FOLDER, MCU_FILES)
     download_files(PYBIND_URL, PYBIND_FOLDER, PYBIND_FILES)
     download_files(PYBIND_URL, PYBIND_FOLDER, PYBIND_EXTRA_FILES)
+    download_files(STB_IMAGE_URL, MCU_FOLDER, ["stb_image.h"])
+    
+    # write __init__.py
+    with open(os.path.join(MCU_FOLDER, "__init__.py"), "w") as file:
+        file.write("from .celebi import QuantizeCelebi, StbLoadImage")
+        file.close()
+    
     if should_apply:
         print("[Info]: Applying patch: ", PATCH_FILE)
         os.system(
@@ -639,7 +653,6 @@ def download_files(base_url, folder, file_map):
     author="Ansh Dadwal",
     author_email="[email protected]",
     packages=find_packages(),
-    install_requires=["pillow"],
     long_description=long_description,
     long_description_content_type="text/markdown",
     exclude=["README.md", "*.pyc", "example.py"],

tests/test_all.py

@@ -5,7 +5,7 @@
 from timeit import default_timer
 import sys
 from materialyoucolor.utils.color_utils import rgba_from_argb
-from materialyoucolor.quantize import QuantizeCelebi
+from materialyoucolor.quantize import QuantizeCelebi, StbLoadImage
 from materialyoucolor.score.score import Score
 from materialyoucolor.hct import Hct
 from materialyoucolor.dynamiccolor.material_dynamic_colors import MaterialDynamicColors
@@ -47,7 +47,11 @@
 image_data = image.getdata()
 pixel_array = [image_data[_] for _ in range(0, pixel_len, int(sys.argv[2]))]
 end = default_timer()
-print("File open took : ", end - start, "secs")
+print("File open took [pillow]: ", end - start, "secs")
+start = default_timer()
+pixel_array = StbLoadImage(FILENAME)
+end = default_timer()
+print("File open took [stb_image]: ", end - start, "secs")
 
 start = default_timer()
 colors = QuantizeCelebi(pixel_array, MAX_COLOR)