[Feature]: Implement zero-copy conversion for NumPy arrays to Image

[sidd-27]

Title: Implement zero-copy conversion for NumPy arrays to Image

Description

The impl_pyarray_to_image macro currently performs a deep copy when converting Python NumPy arrays to Rust Image structs:

// TODO: we should find a way to avoid copying the data
let data = match pyarray.to_vec() { ... }

Calling to_vec() allocates new memory on the Rust heap and copies the entire image buffer. For high-resolution images or video streams, this introduces significant latency and doubles memory usage.

The goal is to resolve the TODO by implementing a mechanism (such as a custom Storage or Allocator backend) that allows the Rust Image struct to reference the existing Python memory buffer directly without taking ownership or performing a copy.

[github-actions]

⚠️ Before Submitting a PR

Please wait for a maintainer to approve and assign this issue to you or someone else before submitting a PR. PRs submitted without prior approval and assignment may be closed. See our Contributing Guide for details.

[JasMehta08]

@sidd-27 ,

I went through the issue, the way you said we should implement the custom Storage, i think there would only be the problem of someone using slices.

We can implement a PyStorage backend that allows the Rust struct to borrow the Python memory (holding the PyArray handle to stop it from being freed). To handle the "slices" case, we can just check is_c_contiguous() inside the conversion macro. If it's a contiguous "whole array," we do the zero-copy optimization; if it's a non-contiguous slice, we can just fall back to the existing to_vec() copy behavior.

and to make sure backwards compatibility is there, we can set Vec<T> as the default generic parameter for the Image struct (e.g., struct Image<..., S = Vec<T>>).

can i get this issue assigned, i will look into and implement it.

[edgarriba]

we need to make sure that sooner than later we'll have to support GPU images

[JasMehta08]

@edgarriba, regarding the custom Storage implementation,

Currently, Image implements Deref<Target=Tensor3>. If we change Image to use a generic Storage trait (to support Python/GPUs), we will likely need to remov this Deref inheritance. This is because Tensor3 is coupled to the Allocator trait, and the new custom backends (like PyStorage) won't fit the strict allocation behaviour that Tensor3 expects.

If I make the change then, Image will stop behaving exactly like a Tensor. the ability to call tensor methods (like .reshape() or .permute()) directly will be lost on an Image unless we re-implement them manually.

how should i go about doing this? Am i ok to remove the Deref for this change?