converting to and fro from open cv mat

[prashant-saxena]

nanobind 2.7.0
python 3.10.0
windows 10

Numpy ndarray to OpenCv Mat conversion: Code is getting compiled but I haven't tested it. Just posting for suggestion if something is wrongly done.

cv::Mat PyScene::ndarray_to_mat(
    nb::ndarray<> arr) {
    
    if (arr.ndim() != 2 && arr.ndim() != 3) {
        RUNTIME_ERROR("Unsupported ndarray dimensions for cv::Mat");
    }

    int rows = static_cast<int>(arr.shape(0));
    int cols = static_cast<int>(arr.shape(1));
    int type = CV_8UC1;  // You may want to handle types more robustly

    if (arr.ndim() == 3) {
        int channels = static_cast<int>(arr.shape(2));
        if (channels == 3) {
            type = CV_8UC3;
        } else if (channels == 4) {
            type = CV_8UC4;
        }
        // Add more handling if needed
    }

    // This is safe: nanobind guarantees alignment and contiguity if array is properly shaped
    return cv::Mat(rows, cols, type, arr.data());
}

This is the code to convert mat to numpy is not at all getting compiled

nb::ndarray<nb::numpy> PyScene::mat_to_ndarray(const cv::Mat& mat) {
    if (mat.empty()) {
        return nb::ndarray<nb::numpy>(); // Return an empty array
    }

    // Determine data type
    nb::dtype dtype;
    switch (mat.depth()) {
        case CV_8U:  dtype = nb::dtype<uint8_t>(); break;
        case CV_8S:  dtype = nb::dtype<int8_t>(); break;
        case CV_16U: dtype = nb::dtype<uint16_t>(); break;
        case CV_16S: dtype = nb::dtype<int16_t>(); break;
        case CV_32S: dtype = nb::dtype<int32_t>(); break;
        case CV_32F: dtype = nb::dtype<float>(); break;
        case CV_64F: dtype = nb::dtype<double>(); break;
        default: throw std::runtime_error("Unsupported OpenCV Mat depth");
    }

    // Determine shape and strides
    std::vector<size_t> shape;
    std::vector<size_t> strides;

    if (mat.channels() > 1) {
        shape = { (size_t)mat.rows, (size_t)mat.cols, (size_t)mat.channels() };
        strides = { (size_t)mat.step[0], (size_t)mat.elemSize1(), (size_t)mat.elemSize1() / mat.channels() }; // Example for interleaved channels
    } else {
        shape = { (size_t)mat.rows, (size_t)mat.cols };
        strides = { (size_t)mat.step[0], (size_t)mat.elemSize1() };
    }

    // Create ndarray, sharing data with the cv::Mat
    // Pass 'nullptr' as owner if the Mat's lifetime is managed externally
    return nb::ndarray<nb::numpy>(mat.data, shape.size(), shape.data(), strides.data(), nb::handle(), dtype);
}

Document says that gil must be released when calling this function

.def("mat_to_ndarray", &PyScene::mat_to_ndarray, nb::call_guard<nb::gil_scoped_release>())

Is this is sufficient?