blending_simulator_lib 2026.1__tar.gz

blending_simulator_lib-2026.1/CMakeLists.txt

@@ -0,0 +1,41 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(
+    ${SKBUILD_PROJECT_NAME}
+    VERSION ${SKBUILD_PROJECT_VERSION}
+    LANGUAGES CXX
+)
+
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+find_package(pybind11 CONFIG REQUIRED)
+
+include(FetchContent)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+FetchContent_Declare(
+    blending-simulation
+    GIT_REPOSITORY https://github.com/jcbachmann/blending-simulation
+    GIT_TAG master
+)
+FetchContent_MakeAvailable(blending-simulation)
+
+pybind11_add_module(
+    _blending_simulator_lib
+    src/blending_simulator_lib/_bindings.cpp
+)
+
+set_target_properties(
+    _blending_simulator_lib PROPERTIES
+    CXX_STANDARD_REQUIRED 17
+)
+
+target_link_libraries(
+    _blending_simulator_lib PRIVATE
+    BlendingSimulator::Lib
+    BlendingSimulator::FastLib
+    BlendingSimulator::DetailedLib
+    pybind11::pybind11
+)
+
+install(TARGETS _blending_simulator_lib DESTINATION ${SKBUILD_PROJECT_NAME})

blending_simulator_lib-2026.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Cipold
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

blending_simulator_lib-2026.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: blending_simulator_lib
+Version: 2026.1
+Summary: Blending Simulation for Bulk Material Homogenization
+Keywords: blending,simulation,cpp,pybind11,bmh
+Author-Email: Michael Cipold <github@cipold.de>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Project-URL: Homepage, https://github.com/jcbachmann/blending-evaluation
+Project-URL: Repository, https://github.com/jcbachmann/blending-evaluation
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pybind11-stubgen; extra == "dev"
+Description-Content-Type: text/markdown
+
+# Blending Simulator Lib (blending_simulator_lib)
+
+[![PyPI version](https://img.shields.io/pypi/v/blending_simulator_lib.svg)](https://pypi.org/project/blending_simulator_lib/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Simulation library for Bulk Material Homogenization, implemented in C++.
+
+## Development
+
+After making changes to the module, you need to regenerate the stubs. To regenerate the stubs, execute this command from
+the package directory:
+
+```bash
+uv run pybind11-stubgen blending_simulator_lib._blending_simulator_lib -o src
+```

blending_simulator_lib-2026.1/README.md

@@ -0,0 +1,15 @@
+# Blending Simulator Lib (blending_simulator_lib)
+
+[![PyPI version](https://img.shields.io/pypi/v/blending_simulator_lib.svg)](https://pypi.org/project/blending_simulator_lib/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Simulation library for Bulk Material Homogenization, implemented in C++.
+
+## Development
+
+After making changes to the module, you need to regenerate the stubs. To regenerate the stubs, execute this command from
+the package directory:
+
+```bash
+uv run pybind11-stubgen blending_simulator_lib._blending_simulator_lib -o src
+```

blending_simulator_lib-2026.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["scikit-build-core", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "blending_simulator_lib"
+version = "2026.1"
+description = "Blending Simulation for Bulk Material Homogenization"
+keywords = ["blending", "simulation", "cpp", "pybind11", "bmh"]
+readme = "README.md"
+authors = [
+    { name = "Michael Cipold", email = "github@cipold.de" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "numpy>=1.20.0",
+]
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C++",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+]
+
+[project.urls]
+Homepage = "https://github.com/jcbachmann/blending-evaluation"
+Repository = "https://github.com/jcbachmann/blending-evaluation"
+
+[project.optional-dependencies]
+dev = ["pybind11-stubgen"]
+
+[tool.setuptools.package-data]
+"blending_simulator_lib" = ["_blending_simulator_lib.pyi", "py.typed"]
+
+[tool.scikit-build]
+wheel.py-api = "cp312"
+cmake.args = [
+    "-DBUILD_VISUALIZER=OFF",
+    "-DBUILD_TESTS=OFF",
+    "-DBUILD_CLI=OFF",
+    "-DBUILD_FAST_SIMULATOR=ON",
+    "-DBUILD_DETAILED_SIMULATOR=ON"
+]

blending_simulator_lib-2026.1/src/blending_simulator_lib/__init__.py

@@ -0,0 +1,5 @@
+from ._blending_simulator_lib import BlendingSimulatorLib
+
+__all__ = [
+    "BlendingSimulatorLib",
+]

blending_simulator_lib-2026.1/src/blending_simulator_lib/_bindings.cpp

@@ -0,0 +1,167 @@
+#include <iostream>
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+#include "BlendingSimulator/BlendingSimulatorFast.h"
+#include "BlendingSimulator/BlendingSimulatorDetailed.h"
+#include "BlendingSimulator/ParticleParameters.h"
+
+namespace bs = blendingsimulator;
+
+class BlendingSimulatorLibPython
+{
+	public:
+		BlendingSimulatorLibPython(float heapWorldSizeX, float heapWorldSizeZ, float reclaimAngle, float particlesPerCubicMeter, bool circular,
+			float eightLikelihood, float bulkDensityFactor, float dropHeight, bool detailed, float reclaimIncrement)
+			: reclaimIncrement(reclaimIncrement)
+			, verbose(false)
+		{
+			bs::SimulationParameters simulationParameters{
+				heapWorldSizeX,
+				heapWorldSizeZ,
+				reclaimAngle,
+				particlesPerCubicMeter,
+				circular,
+				eightLikelihood,
+				false, // visualize - not available in python library
+				bulkDensityFactor,
+				dropHeight
+			};
+
+			if (detailed) {
+				simulator = new bs::BlendingSimulatorDetailed<bs::AveragedParameters>(simulationParameters);
+			} else {
+				simulator = new bs::BlendingSimulatorFast<bs::AveragedParameters>(simulationParameters);
+			}
+		}
+
+		~BlendingSimulatorLibPython()
+		{
+			delete simulator;
+		}
+
+		void stack(double timestamp, float x, float z, double volume, const std::vector<double>& parameter)
+		{
+			simulator->stack(x, z, bs::AveragedParameters(volume, parameter));
+		}
+
+		void stackList(const py::array_t<double>& data, const std::vector<std::string>& columns)
+		{
+//			int timestampCol = -1;
+			int xCol = -1;
+			int zCol = -1;
+			int volumeCol = -1;
+			std::vector<int> parameterColumnIndices;
+
+			for (int i = 0; i < columns.size(); i++) {
+				if (columns[i] == "timestamp") {
+//					timestampCol = i;
+				} else if (columns[i] == "x") {
+					xCol = i;
+				} else if (columns[i] == "z") {
+					zCol = i;
+				} else if (columns[i] == "volume") {
+					volumeCol = i;
+				} else {
+					parameterColumnIndices.push_back(i);
+					parameterColumns.push_back(columns[i]);
+				}
+			}
+
+			auto dataRef = data.unchecked<2>();
+
+			for (py::ssize_t i = 0; i < dataRef.shape(0); i++) {
+				std::vector<double> values(parameterColumnIndices.size());
+				for (int j = 0; j < parameterColumnIndices.size(); j++) {
+					values[j] = dataRef(i, parameterColumnIndices[j]);
+				}
+				simulator->stack(
+					(float)dataRef(i, xCol),
+					(float)dataRef(i, zCol),
+					bs::AveragedParameters(dataRef(i, volumeCol), values)
+				);
+			}
+		}
+
+		py::dict reclaim()
+		{
+			finishStacking();
+
+			if (verbose) {
+				std::cerr << "Reclaiming" << std::endl;
+			}
+
+			py::list x;
+			py::list volume;
+			std::vector<py::list> parameter(parameterColumns.size());
+
+			float position = 0.0f;
+			while (!simulator->reclaimingFinished()) {
+				bs::AveragedParameters p = simulator->reclaim(position);
+				x.append(position);
+				volume.append(p.getVolume());
+				const auto& values = p.getValues();
+				for (int i = 0; i < parameterColumns.size(); i++) {
+					parameter[i].append(i < values.size() ? values[i] : 0);
+				}
+				position += reclaimIncrement;
+			}
+
+			py::dict ret("x"_a = x, "volume"_a = volume);
+			for (int i = 0; i < parameterColumns.size(); i++) {
+				ret[parameterColumns[i].c_str()] = parameter[i];
+			}
+			return ret;
+		}
+
+		std::vector<std::vector<float>> getHeights()
+		{
+			finishStacking();
+
+			if (verbose) {
+				std::cerr << "Acquiring heights" << std::endl;
+			}
+
+			auto heapMapSize = simulator->getHeapMapSize();
+			std::vector<std::vector<float>> heights;
+			heights.reserve(heapMapSize.second);
+			const float* heapMap = simulator->getHeapMap(); // +1 for Y coordinate
+			for (int z = 0; z < heapMapSize.second; z++) {
+				heights.emplace_back(heapMap + z * heapMapSize.first + 1, heapMap + z * heapMapSize.first + 1 + heapMapSize.first);
+			}
+
+			return heights;
+		}
+
+	private:
+		bs::BlendingSimulator<bs::AveragedParameters>* simulator;
+		float reclaimIncrement;
+		std::vector<std::string> parameterColumns;
+		bool verbose;
+
+		void finishStacking()
+		{
+			simulator->finishStacking();
+
+			if (verbose) {
+				std::cerr << "Stacking finished" << std::endl;
+			}
+		}
+};
+
+PYBIND11_MODULE(_blending_simulator_lib, m)
+{
+	m.doc() = "Blending Simulator Lib for Python";
+
+	py::class_<BlendingSimulatorLibPython>(m, "BlendingSimulatorLib")
+		.def(py::init<float, float, float, float, bool, float, float, float, bool, float>())
+		.def("stack", &BlendingSimulatorLibPython::stack)
+		.def("stack_list", &BlendingSimulatorLibPython::stackList)
+		.def("reclaim", &BlendingSimulatorLibPython::reclaim)
+		.def("get_heights", &BlendingSimulatorLibPython::getHeights);
+}

blending_simulator_lib-2026.1/src/blending_simulator_lib/_blending_simulator_lib.pyi

@@ -0,0 +1,39 @@
+"""
+Blending Simulator Lib for Python
+"""
+
+from __future__ import annotations
+
+import collections.abc
+import typing
+
+import numpy
+import numpy.typing
+
+__all__: list[str] = ["BlendingSimulatorLib"]
+
+class BlendingSimulatorLib:
+    def __init__(
+        self,
+        arg0: typing.SupportsFloat | typing.SupportsIndex,
+        arg1: typing.SupportsFloat | typing.SupportsIndex,
+        arg2: typing.SupportsFloat | typing.SupportsIndex,
+        arg3: typing.SupportsFloat | typing.SupportsIndex,
+        arg4: bool,
+        arg5: typing.SupportsFloat | typing.SupportsIndex,
+        arg6: typing.SupportsFloat | typing.SupportsIndex,
+        arg7: typing.SupportsFloat | typing.SupportsIndex,
+        arg8: bool,
+        arg9: typing.SupportsFloat | typing.SupportsIndex,
+    ) -> None: ...
+    def get_heights(self) -> list[list[float]]: ...
+    def reclaim(self) -> dict: ...
+    def stack(
+        self,
+        arg0: typing.SupportsFloat | typing.SupportsIndex,
+        arg1: typing.SupportsFloat | typing.SupportsIndex,
+        arg2: typing.SupportsFloat | typing.SupportsIndex,
+        arg3: typing.SupportsFloat | typing.SupportsIndex,
+        arg4: collections.abc.Sequence[typing.SupportsFloat | typing.SupportsIndex],
+    ) -> None: ...
+    def stack_list(self, arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], arg1: collections.abc.Sequence[str]) -> None: ...