ad4719c10c
We are using pybind11 'smart_holder' branch to solve the Camera destructor issue (see the comment in this patch, or the commit that originally added Python bindings support). As it would be very nice to use the mainline pybind11 (which is packaged in distributions), this patch adds a workaround allowing us to move to the mainline pybind11 version. The workaround is simply creating a custom holder class (PyCameraSmartPtr), used only for the Camera, which wraps around the shared_ptr. This makes the compiler happy. Moving to mainline pybind11 is achieved with: - Change the pybind11 wrap to point to the mainline pybdind11 version - Tell pybind11 to always use shared_ptr<> as the holder for PyCameraManager, as we use the singleton pattern for the PyCameraManager, and using shared_ptr<> to manage it is a requirement - Tell pybind11 to always use PyCameraSmartPtr<> as the holder for Camera - Change the meson.build file to use a system-installed pybind11 Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ideasonboard.com> Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com> Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
120 lines
3.8 KiB
C++
120 lines
3.8 KiB
C++
/* SPDX-License-Identifier: LGPL-2.1-or-later */
|
|
/*
|
|
* Copyright (C) 2022, Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>
|
|
*
|
|
* Python bindings - Geometry classes
|
|
*/
|
|
|
|
#include <array>
|
|
|
|
#include <libcamera/geometry.h>
|
|
#include <libcamera/libcamera.h>
|
|
|
|
#include <pybind11/operators.h>
|
|
#include <pybind11/pybind11.h>
|
|
#include <pybind11/stl.h>
|
|
|
|
namespace py = pybind11;
|
|
|
|
using namespace libcamera;
|
|
|
|
void init_py_geometry(py::module &m)
|
|
{
|
|
auto pyPoint = py::class_<Point>(m, "Point");
|
|
auto pySize = py::class_<Size>(m, "Size");
|
|
auto pySizeRange = py::class_<SizeRange>(m, "SizeRange");
|
|
auto pyRectangle = py::class_<Rectangle>(m, "Rectangle");
|
|
|
|
pyPoint
|
|
.def(py::init<>())
|
|
.def(py::init<int, int>())
|
|
.def_readwrite("x", &Point::x)
|
|
.def_readwrite("y", &Point::y)
|
|
.def(py::self == py::self)
|
|
.def(-py::self)
|
|
.def("__str__", &Point::toString)
|
|
.def("__repr__", [](const Point &self) {
|
|
return py::str("libcamera.Point({}, {})")
|
|
.format(self.x, self.y);
|
|
});
|
|
|
|
pySize
|
|
.def(py::init<>())
|
|
.def(py::init<unsigned int, unsigned int>())
|
|
.def_readwrite("width", &Size::width)
|
|
.def_readwrite("height", &Size::height)
|
|
.def_property_readonly("is_null", &Size::isNull)
|
|
.def("align_down_to", &Size::alignDownTo)
|
|
.def("align_up_to", &Size::alignUpTo)
|
|
.def("bound_to", &Size::boundTo)
|
|
.def("expand_to", &Size::expandTo)
|
|
.def("grow_by", &Size::growBy)
|
|
.def("shrink_by", &Size::shrinkBy)
|
|
.def("aligned_up_to", &Size::alignedUpTo)
|
|
.def("aligned_up_to", &Size::alignedUpTo)
|
|
.def("bounded_to", &Size::boundedTo)
|
|
.def("expanded_to", &Size::expandedTo)
|
|
.def("grown_by", &Size::grownBy)
|
|
.def("shrunk_by", &Size::shrunkBy)
|
|
.def("bounded_to_aspect_ratio", &Size::boundedToAspectRatio)
|
|
.def("expanded_to_aspect_ratio", &Size::expandedToAspectRatio)
|
|
.def("centered_to", &Size::centeredTo)
|
|
.def(py::self == py::self)
|
|
.def(py::self < py::self)
|
|
.def(py::self <= py::self)
|
|
.def(py::self * float())
|
|
.def(py::self / float())
|
|
.def(py::self *= float())
|
|
.def(py::self /= float())
|
|
.def("__str__", &Size::toString)
|
|
.def("__repr__", [](const Size &self) {
|
|
return py::str("libcamera.Size({}, {})")
|
|
.format(self.width, self.height);
|
|
});
|
|
|
|
pySizeRange
|
|
.def(py::init<>())
|
|
.def(py::init<Size>())
|
|
.def(py::init<Size, Size>())
|
|
.def(py::init<Size, Size, unsigned int, unsigned int>())
|
|
.def_readwrite("min", &SizeRange::min)
|
|
.def_readwrite("max", &SizeRange::max)
|
|
.def_readwrite("hStep", &SizeRange::hStep)
|
|
.def_readwrite("vStep", &SizeRange::vStep)
|
|
.def("contains", &SizeRange::contains)
|
|
.def(py::self == py::self)
|
|
.def("__str__", &SizeRange::toString)
|
|
.def("__repr__", [](const SizeRange &self) {
|
|
return py::str("libcamera.SizeRange(({}, {}), ({}, {}), {}, {})")
|
|
.format(self.min.width, self.min.height,
|
|
self.max.width, self.max.height,
|
|
self.hStep, self.vStep);
|
|
});
|
|
|
|
pyRectangle
|
|
.def(py::init<>())
|
|
.def(py::init<int, int, Size>())
|
|
.def(py::init<int, int, unsigned int, unsigned int>())
|
|
.def(py::init<Size>())
|
|
.def_readwrite("x", &Rectangle::x)
|
|
.def_readwrite("y", &Rectangle::y)
|
|
.def_readwrite("width", &Rectangle::width)
|
|
.def_readwrite("height", &Rectangle::height)
|
|
.def_property_readonly("is_null", &Rectangle::isNull)
|
|
.def_property_readonly("center", &Rectangle::center)
|
|
.def_property_readonly("size", &Rectangle::size)
|
|
.def_property_readonly("topLeft", &Rectangle::topLeft)
|
|
.def("scale_by", &Rectangle::scaleBy)
|
|
.def("translate_by", &Rectangle::translateBy)
|
|
.def("bounded_to", &Rectangle::boundedTo)
|
|
.def("enclosed_in", &Rectangle::enclosedIn)
|
|
.def("scaled_by", &Rectangle::scaledBy)
|
|
.def("translated_by", &Rectangle::translatedBy)
|
|
.def(py::self == py::self)
|
|
.def("__str__", &Rectangle::toString)
|
|
.def("__repr__", [](const Rectangle &self) {
|
|
return py::str("libcamera.Rectangle({}, {}, {}, {})")
|
|
.format(self.x, self.y, self.width, self.height);
|
|
});
|
|
}
|