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

Mikhail V mikhailwas at gmail.com
Fri Jun 30 16:08:54 EDT 2017

```On 30 June 2017 at 03:34, Joseph Fox-Rabinovitz
<jfoxrabinovitz at gmail.com> wrote:
> This is a useful idea certainly. I would recommended extending it to an
> arbitrary number of axes. You could either raise an error if the ndim of the
> two arrays are unequal, or allow a broadcast of a lesser ndimmed src array.
>

Now I am thinking that there is probably an even better, more generalised
way to provide this functionality.
Say if we had a function "intersect" which would be defined as follows:

intersect(A, B, offset)

where A, B are vector endpoints, and the offset is the distance
between their origins.
So to find a needed slice I could simply pass the shapes:

intersect (DEST.shape, SRC.shape, offset)

Hmm. there is something to think about. Could be a
better idea to propose this, since it could be used in many
other sitiations, not only for finding slice intersection.

Although I'll need some time to think out more examples and use cases.

Mikhail

>
> On Jun 29, 2017 20:17, "Mikhail V" <mikhailwas at gmail.com> 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.
>>
>>
>> Mikhail
>> _______________________________________________
>> NumPy-Discussion mailing list
>> NumPy-Discussion at python.org
>> https://mail.python.org/mailman/listinfo/numpy-discussion
>
>
> _______________________________________________
> NumPy-Discussion mailing list
> NumPy-Discussion at python.org
> https://mail.python.org/mailman/listinfo/numpy-discussion
>
```