# [Numpy-discussion] Array blitting (pasting one array into another)

Sebastian Berg sebastian at sipsolutions.net
Fri Jun 30 02:04:27 EDT 2017

```On Fri, 2017-06-30 at 02:16 +0200, Mikhail V wrote:
> Hello all
>
> I often need to copy one array into another array, given an offset.
> This is how the "blit" function can be understood, i.e. in
> every graphical lib there is such a function.
> The common definition is like:
> blit ( dest, src, offset ):
> where dest is destination array, src is source array and offset is
> coordinates in destination where the src should pe blitted.
> Main feature of such function is that it never gives an error,
> so if the source does not fit into the destination array, it is
> simply trimmed.
> And respectively if there is no intersection area then nothing
> happens.
>
> Hope this is clear.
> So to make it work with Numpy arrays one need to calculate the
> slices before copying the data.
> I cannot find any Numpy or Python method to help with that so
> probably
> it does not exist yet.
> If so, my proposal is to add a Numpy method which helps with that.
> Namely the proposal will be to add a method which returns
> the slices for the intersection areas of two arbitrary arrays, given
> an offset,
> so then one can "blit" the array into another with simple assignment
> =.
>
> Here is a Python function I use for 2d arrays now:
>
> def interslice ( dest, src, offset ):
>     y,x = offset
>     H,W = dest.shape
>     h,w = src.shape
>
>     dest_starty = max (y,0)
>     dest_endy = min (y+h,H)
>     dest_startx = max (x,0)
>     dest_endx = min (x+w,W)
>
>     src_starty = 0
>     src_endy = h
>     if y<0:     src_starty = -y
>     by = y+h - H             # Y bleed
>     if by>0: src_endy = h - by
>
>     src_startx = 0
>     src_endx = w
>     if x<0:  src_startx = -x
>     bx = x+w - W             # X bleed
>     if bx>0:  src_endx = w - bx
>
>     dest_sliceY =  slice(dest_starty,dest_endy)
>     dest_sliceX =  slice(dest_startx,dest_endx)
>     src_sliceY = slice(src_starty, src_endy)
>     src_sliceX = slice(src_startx, src_endx)
>     if dest_endy <= dest_starty:
>         print "No Y intersection !"
>         dest_sliceY = ( slice(0, 0) )
>         src_sliceY = ( slice(0, 0) )
>     if dest_endx <= dest_startx:
>         print "No X intersection !"
>         dest_sliceX = ( slice(0, 0) )
>         src_sliceX = ( slice(0, 0) )
>     dest_slice = ( dest_sliceY, dest_sliceX )
>     src_slice = ( src_sliceY, src_sliceX )
>     return ( dest_slice, src_slice )
>
>
> ------
>
> I have intentionally made it expanded and without contractions
> so that it is better understandable.
> It returns the intersection area of two arrays given an offset.
> First returned tuple element is the slice for DEST array and the
> second element is the slice for SRC array.
> If there is no intersection along one of the axis at all
> it returns the corresponding slice as (0,0)
>
> With this helper function one can blit arrays easily e.g. example
> code:
>
> W = 8; H = 8
> DEST = numpy.ones([H,W], dtype = "uint8")
> w = 4; h = 1
> SRC = numpy.zeros([h,w], dtype = "uint8")
> SRC[:]=8
> offset = (0,9)
> ds, ss = interslice (DEST, SRC, offset )
>
> # blit SRC into DEST
> DEST[ds] = SRC[ss]
>
> So changing the offset one can observe how the
> SRC array is trimmed if it is crosses the DEST boundaries.
> I think it is very useful function in general and it has
> well defined behaviour. It has usage not only for graphics,
> but actually any data copying-pasting between arrays.
>
> So I am looking forward to comments on this proposal.
>

First, the slice object provides some help:
```
In [8]: s = slice(1, 40, 2)

In [9]: s.indices(20)  # length of dimension
Out[9]: (1, 20, 2)  # and the 40 becomes 20

```

Second, there is almost no overhead of creating a view, so just create
the views first (it may well be faster). Then use the result to see how
large they actually are and index those (a second time) instead of
creating new slice objects.

- Sebastian

>
> Mikhail
> _______________________________________________
> NumPy-Discussion mailing list
> NumPy-Discussion at python.org
> https://mail.python.org/mailman/listinfo/numpy-discussion
>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 801 bytes
Desc: This is a digitally signed message part
URL: <http://mail.python.org/pipermail/numpy-discussion/attachments/20170630/921447b8/attachment.sig>
```