Skip to content

Pypi release fixes #257

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mattalvarado merged 4 commits into from
Dec 15, 2025
Merged

Pypi release fixes #257

Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
3057631
Fix windows wheel builds
mattalvarado Dec 9, 2025
980bb8c
Revert some changes
mattalvarado Dec 15, 2025
f7d4b5b
Revert change
mattalvarado Dec 15, 2025
aadefa4
Merge branch 'master' into malvarado/pypi_release_fixes
mattalvarado Dec 15, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
127 changes: 86 additions & 41 deletions python/bindings.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -74,6 +74,10 @@

namespace py = pybind11;

namespace {
using SSizeVector = std::vector<py::ssize_t>;
}

PYBIND11_MODULE(_libmultisense, m) {
m.doc() = "Pybind11 bindings for the LibMultiSense C++ Library";

Expand Down Expand Up @@ -161,49 +165,58 @@ PYBIND11_MODULE(_libmultisense, m) {
if (image.format == multisense::Image::PixelFormat::H264 ||
image.format == multisense::Image::PixelFormat::JPEG)
{
const SSizeVector shape = {
static_cast<py::ssize_t>(image.raw_data->size() - image.image_data_offset)
};
const SSizeVector strides = {static_cast<py::ssize_t>(sizeof(uint8_t))};
return py::array(py::buffer_info(
const_cast<uint8_t*>(image.raw_data->data() + image.image_data_offset),
sizeof(uint8_t),
static_cast<py::ssize_t>(sizeof(uint8_t)),
py::format_descriptor<uint8_t>::format(),
1,
{image.raw_data->size() - image.image_data_offset},
{sizeof(uint8_t)}));
shape,
strides));
}

std::vector<size_t> shape = {static_cast<size_t>(image.height), static_cast<size_t>(image.width)};
std::vector<size_t> strides;
size_t element_size = 0;
SSizeVector shape = {static_cast<py::ssize_t>(image.height), static_cast<py::ssize_t>(image.width)};
SSizeVector strides;
py::ssize_t element_size = 0;
std::string format;

switch (image.format)
{
case multisense::Image::PixelFormat::MONO8:
{
element_size = sizeof(uint8_t);
element_size = static_cast<py::ssize_t>(sizeof(uint8_t));
format = py::format_descriptor<uint8_t>::format();
strides = {sizeof(uint8_t) * image.width, sizeof(uint8_t)};
strides = {static_cast<py::ssize_t>(sizeof(uint8_t) * image.width),
static_cast<py::ssize_t>(sizeof(uint8_t))};
break;
}
case multisense::Image::PixelFormat::MONO16:
{
element_size = sizeof(uint16_t);
element_size = static_cast<py::ssize_t>(sizeof(uint16_t));
format = py::format_descriptor<uint16_t>::format();
strides = {sizeof(uint16_t) * image.width, sizeof(uint16_t)};
strides = {static_cast<py::ssize_t>(sizeof(uint16_t) * image.width),
static_cast<py::ssize_t>(sizeof(uint16_t))};
break;
}
case multisense::Image::PixelFormat::BGR8:
{
element_size = sizeof(uint8_t);
element_size = static_cast<py::ssize_t>(sizeof(uint8_t));
format = py::format_descriptor<uint8_t>::format();
shape.push_back(3);
strides = {sizeof(uint8_t) * image.width * 3, sizeof(uint8_t) * 3, sizeof(uint8_t)};
strides = {static_cast<py::ssize_t>(sizeof(uint8_t) * image.width * 3),
static_cast<py::ssize_t>(sizeof(uint8_t) * 3),
static_cast<py::ssize_t>(sizeof(uint8_t))};
break;
}
case multisense::Image::PixelFormat::FLOAT32:
{
element_size = sizeof(float);
element_size = static_cast<py::ssize_t>(sizeof(float));
format = py::format_descriptor<float>::format();
strides = {sizeof(float) * image.width, sizeof(float)};
strides = {static_cast<py::ssize_t>(sizeof(float) * image.width),
static_cast<py::ssize_t>(sizeof(float))};
break;
}
default: {throw std::runtime_error("Unknown pixel format");}
Expand All @@ -214,7 +227,7 @@ PYBIND11_MODULE(_libmultisense, m) {
const_cast<uint8_t*>(image.raw_data->data() + image.image_data_offset),
element_size,
format,
shape.size(),
static_cast<py::ssize_t>(shape.size()),
shape,
strides));
})
Expand All @@ -233,17 +246,17 @@ PYBIND11_MODULE(_libmultisense, m) {
.def_readonly("bins", &multisense::ImageHistogram::bins)
.def_property_readonly("as_array", [](const multisense::ImageHistogram& histogram)
{
std::vector<size_t> shape{histogram.data.size()};
std::vector<size_t> strides{sizeof(uint32_t)};
size_t element_size = sizeof(uint32_t);
const SSizeVector shape{static_cast<py::ssize_t>(histogram.data.size())};
const SSizeVector strides{static_cast<py::ssize_t>(sizeof(uint32_t))};
const py::ssize_t element_size = static_cast<py::ssize_t>(sizeof(uint32_t));
std::string format = py::format_descriptor<uint32_t>::format();

// Map the cv::Mat to a NumPy array without copying the data
return py::array(py::buffer_info(
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(histogram.data.data())),
element_size,
format,
shape.size(),
static_cast<py::ssize_t>(shape.size()),
shape,
strides));
});
Expand Down Expand Up @@ -741,16 +754,22 @@ PYBIND11_MODULE(_libmultisense, m) {
.def_readwrite("cloud", &multisense::PointCloud<void>::cloud)
.def_property_readonly("as_array", [](const multisense::PointCloud<void> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size()), 3};
const std::vector<size_t> strides = {sizeof(multisense::Point<void>), sizeof(float)};
const size_t element_size = sizeof(float);
const SSizeVector shape = {
static_cast<py::ssize_t>(cloud.cloud.size()),
static_cast<py::ssize_t>(3)
};
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<void>)),
static_cast<py::ssize_t>(sizeof(float))
};
const py::ssize_t element_size = static_cast<py::ssize_t>(sizeof(float));
const std::string format = py::format_descriptor<float>::format();;

return py::array(py::buffer_info(
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(cloud.cloud.data())),
element_size,
format,
shape.size(),
static_cast<py::ssize_t>(shape.size()),
shape,
strides));
});
Expand All @@ -760,12 +779,18 @@ PYBIND11_MODULE(_libmultisense, m) {
.def_readwrite("cloud", &multisense::PointCloud<uint8_t>::cloud)
.def_property_readonly("as_array", [](const multisense::PointCloud<uint8_t> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size()), 3};
const SSizeVector shape = {
static_cast<py::ssize_t>(cloud.cloud.size()),
static_cast<py::ssize_t>(3)
};
//
// Make sure we skip over the color
//
const std::vector<size_t> strides = {sizeof(multisense::Point<uint8_t>), sizeof(float)};
const size_t element_size = sizeof(multisense::Point<uint8_t>);
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<uint8_t>)),
static_cast<py::ssize_t>(sizeof(float))
};
const py::ssize_t element_size = static_cast<py::ssize_t>(sizeof(multisense::Point<uint8_t>));
const std::string format = py::format_descriptor<float>::format();;

return py::array(py::buffer_info(
Expand All @@ -778,9 +803,11 @@ PYBIND11_MODULE(_libmultisense, m) {
})
.def_property_readonly("as_raw_array", [](const multisense::PointCloud<uint8_t> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size())};
const std::vector<size_t> strides = {sizeof(multisense::Point<uint8_t>)};
const size_t element_size = sizeof(multisense::Point<uint8_t>);
const SSizeVector shape = {static_cast<py::ssize_t>(cloud.cloud.size())};
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<uint8_t>))
};
const py::ssize_t element_size = static_cast<py::ssize_t>(sizeof(multisense::Point<uint8_t>));

return py::array(py::buffer_info(
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(cloud.cloud.data())),
Expand All @@ -797,12 +824,18 @@ PYBIND11_MODULE(_libmultisense, m) {
.def_readwrite("cloud", &multisense::PointCloud<uint16_t>::cloud)
.def_property_readonly("as_array", [](const multisense::PointCloud<uint16_t> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size()), 3};
const SSizeVector shape = {
static_cast<py::ssize_t>(cloud.cloud.size()),
static_cast<py::ssize_t>(3)
};
//
// Make sure we skip over the color
//
const std::vector<size_t> strides = {sizeof(multisense::Point<uint16_t>), sizeof(float)};
const size_t element_size = sizeof(multisense::Point<uint16_t>);
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<uint16_t>)),
static_cast<py::ssize_t>(sizeof(float))
};
const py::ssize_t element_size = static_cast<py::ssize_t>(sizeof(multisense::Point<uint16_t>));
const std::string format = py::format_descriptor<float>::format();;

return py::array(py::buffer_info(
Expand All @@ -815,9 +848,11 @@ PYBIND11_MODULE(_libmultisense, m) {
})
.def_property_readonly("as_raw_array", [](const multisense::PointCloud<uint16_t> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size())};
const std::vector<size_t> strides = {sizeof(multisense::Point<uint16_t>)};
const size_t element_size = sizeof(multisense::Point<uint16_t>);
const SSizeVector shape = {static_cast<py::ssize_t>(cloud.cloud.size())};
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<uint16_t>))
};
const py::ssize_t element_size = static_cast<py::ssize_t>(sizeof(multisense::Point<uint16_t>));

return py::array(py::buffer_info(
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(cloud.cloud.data())),
Expand All @@ -833,12 +868,19 @@ PYBIND11_MODULE(_libmultisense, m) {
.def_readwrite("cloud", &multisense::PointCloud<std::array<uint8_t, 3>>::cloud)
.def_property_readonly("as_array", [](const multisense::PointCloud<std::array<uint8_t, 3>> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size()), 3};
const SSizeVector shape = {
static_cast<py::ssize_t>(cloud.cloud.size()),
static_cast<py::ssize_t>(3)
};
//
// Make sure we skip over the color
//
const std::vector<size_t> strides = {sizeof(multisense::Point<std::array<uint8_t, 3>>), sizeof(float)};
const size_t element_size = sizeof(multisense::Point<std::array<uint8_t, 3>>);
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<std::array<uint8_t, 3>>)),
static_cast<py::ssize_t>(sizeof(float))
};
const py::ssize_t element_size =
static_cast<py::ssize_t>(sizeof(multisense::Point<std::array<uint8_t, 3>>));
const std::string format = py::format_descriptor<float>::format();;

return py::array(py::buffer_info(
Expand All @@ -851,9 +893,12 @@ PYBIND11_MODULE(_libmultisense, m) {
})
.def_property_readonly("as_raw_array", [](const multisense::PointCloud<std::array<uint8_t, 3>> &cloud)
{
const std::vector<size_t> shape = {static_cast<size_t>(cloud.cloud.size())};
const std::vector<size_t> strides = {sizeof(multisense::Point<std::array<uint8_t, 3>>)};
const size_t element_size = sizeof(multisense::Point<std::array<uint8_t, 3>>);
const SSizeVector shape = {static_cast<py::ssize_t>(cloud.cloud.size())};
const SSizeVector strides = {
static_cast<py::ssize_t>(sizeof(multisense::Point<std::array<uint8_t, 3>>))
};
const py::ssize_t element_size =
static_cast<py::ssize_t>(sizeof(multisense::Point<std::array<uint8_t, 3>>));

return py::array(py::buffer_info(
const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(cloud.cloud.data())),
Expand Down