I have a series of arrays whose physical dimensions are very small, so it is too fiddly to draw them with the mouse. I'm looking for a way to draw data into them using a larger array, which I can control. In other words, I'm looking for a way to do this:

except with arrays instead of number boxes.

This is very easy to achieve using [arraycopy]:

However, this method is inefficient for two reasons:

• [arraycopy] copies all of the data every time it is banged, not just the data that has been changed.
• [arraycopy] needs to be triggered by [metro], so that the data is copied whether or not there is any new data.

Because of this, I would expect this construction to cost a significant amount of CPU with larger arrays, which is something I want to avoid. I'm sure it would be possible to use [tabdump] instead of [arraycopy] and filter out all extraneous data, but this process itself would still cost something.

What I want to know is: is there a way to receive only the array data that has been changed, and only when it has been changed?

Here is what I mean:

In this example, data received from a specific [vsl] will be sent to a specific point on array1 only when it has changed. This method is fine, except it is a bit less elegant, and won't work well when the array is resized. I will resort to this if I have to, but I would prefer to find a way of achieving the same with arrays!

NB. I have even looked into data structure arrays, but from what I can tell, even these need to be banged every time to get the data out. At least this is what's suggested by Frank Barknecht's tutorial (file 19-tut.pd)

Can anyone think of a way of doing this?

@LiamG Well, it nearly works.....if you don't draw too fast!... and with your canvas property skills you will perfect it I am sure!....
Here is an idea for a hack (always looking for good hacks!)....
array_copy.pd
David.
(I apply the /2 because on my screen an array x position uses 2 pixels at this array size..... its a hack!)

@LiamG Although, if you are prepared to right-click and open the array then you could edit it from there. If you expand the array sub-patch to fill the screen, close it, and then save your patch....... then next time you open that sub-patch the graph array will have expanded to fill the whole screen....
lilliput.pd
David.

@whale-av, after careful consideration, I have decided that this last suggestion of yours is the simplest and best. I'll just use the graph window to edit the array when need be, and the "vis $1" command to open and close it. Thanks for your input--I would not have come up with this by myself!

@LiamG Hi, I noticed earlier in this thread that you considered structures as an option, I also tried something similar, but never really ended up using the idea. I actually created a page of 64 across x 8 deep sliders to address slow loading on windows, but it in fact mouse control became an issue. Anyway attached is a bank of 16 pseudo-sliders manipulating an array. the two outer ones have x axis fixed for each index and the middle one is the x/y flowing style. Probably no help whatsoever, but may be of interest. sliderbank-2-top-level.pd is the example file
sliderbank.zip

Nice work @Balwyn ! Those sliders look much nicer than the native ones. How are you getting the data out of the data structure and into the array?

I was afraid you might ask that. Here goes

The two outer slider banks:
The [pd init] in the sliderbank-2 subpatch shows the workings
using
[iemguts/receivecanvas] for the global mouse position
[iemguts/canvasposition] to get the patches position
subtracting the patch position from the mouse position to get the local mouse position. then using [moses] to constrain the x position between 0 and 242 (8 less than the patch's GOP width of 250 which is the right margin).
clicking and holding the mouse button, take the x position
subtract 8 which is the left margin
the divide by the slider spacing of 15
and end up with a number that represents the slider index of that position.
Then moving vertically take the mouse-motion from [receivecanvas] and bang the index to an [element] and [get] and send the index packed with the y position as output and write to array with [tabwrite] the y position is constrained by the structure
Then at the same time [set] the structure array x and y to costrain the x position
This gives the instant update from the slider to the array.
Interestingly holding the shift key results in all the sliders to right to move relatively.

The middle slider bank:
Is much easier
[pd init] in the sliderbank subpatch shows the workings
[iemguts/receivecanvas] for mouseup
mouseup fires a counter 0 to 15
read each element of the structure array with [element] and [get]
output the packed index and y value
again the y position is constrained by the structure [plot -y y(0:-150) nodes 333 w 0 0 15]
The draw back here is the x movement with the mouse button down will affect the y position of each slider crossed, the same as a graphed array

Another problem for with structure plots is the control key allows the deletion and addition of nodes

zorder is also a problem, keeping the controls fully visible is awkward

I also wondered why bother with external arrays at all and just have an internal one that could be read by firing an index at it

the result was s64-8up-grouped.pd in the attached zip
512 sliders.zip

click 'fill sliders with stuff' the click run...
.......
a total disaster
mouse over the sliders and oh! dear!

On the bright side I love doing this stuff

Cheers
Balwyn