drawing lines only between points that are closer than the distance specified

I made a js version using matrices. There is twice as much calculation going on as needed (each vertex is compared with another one twice: "A" to "B" and then again "B" to "A"). I though it might be faster due to using matrices instead of getcell and doing all the cells individually. However the performance is far below expectations so I will make another "getcell" & "arrays" version in hope of better frame rate. This version runs smooth and sexy on my macbook pro for 200 vertices (60fps), a bit slower for 500 (cca 30 fps), 1000 at cca 10 fps and so on.

PS: you need xray.jit.cellcoords to run this patch and hence also 32bit version of Max.

I would also like to know if using jit.gl.sketch is slower then using jit.gl.mesh. In case the mesh option is a better one: how to define which vertices to connect in jit.gl.mesh and which not?

autowatch = 1;
inlets = 1;

var sketch = new JitterObject("jit.gl.sketch","okno"); // jit.sketch draw to render context okno
sketch.lighting_enable = 0;
sketch.cull_face = 0;
sketch.antialias = 1;
sketch.blend_enable = 1;
sketch.depth_enable = 1;

var cellcoords = new JitterObject ("xray.jit.cellcoords");

var min_distance = 0.05;

// create [jit.expr] object for the bang() function
var myexpr = new JitterObject("jit.expr");
myexpr.expr = "in[0].p[0]+in[0].p[1]+in[0].p[2]"; // expression: sum all the planes in the input matrix

// create the Jitter matrices we need to store our data

// matrix of x,y,z particle vertices
var particlemat = new JitterMatrix("jitnoise");
// number of particles defined by "incoming" matrix
var PARTICLE_COUNT = particlemat.dim;
// matrix for aggregate distances
var distmat = new JitterMatrix(3, "float32", PARTICLE_COUNT);
// temporary matrix for the bang_op() function
var tempmat = new JitterMatrix(3, "float32", PARTICLE_COUNT);
// temporary summing matrix for the bang_op() function
var summat = new JitterMatrix(1, "float32", PARTICLE_COUNT);
// matrix of cell coordinates wanted (distances
var celcordmat = new JitterMatrix(1, "float32", PARTICLE_COUNT);
// a scalar matrix to store the current particle that is being compared with the others
var scalarmat = new JitterMatrix(3, "float32", PARTICLE_COUNT);

function min_dist(value)
{
min_distance = value;
}

function bang()
{
    sketch.reset();
    for(var i = 0; i < PARTICLE_COUNT; i++)
    // do one iteration per each particle point
    {
        // choose a particle and call it a probe
        probe = particlemat.getcell(i);
        // create a scalar matrix out of the current probe:
        scalarmat.setall(probe);
        // subtract our particle positions from the current probe
        // and store in a temporary matrix (x,y,z):
        tempmat.op("-", scalarmat, particlemat);
        // square to create a cartesian distance matrix (x*x, y*y, z*z):
        distmat.op("*", tempmat, tempmat);
        // sum the planes of the distance matrix (x*x+y*y+z*z) and output a 1 plane matrix sumat that represent distance
        // "in[0].p[0]+in[0].p[1]+in[0].p[2]" :
        myexpr.matrixcalc(distmat, summat);
     //output a matrix of 0s and 1s. if 1, that cell needs to be connected to probe
        summat.op ("
        //find coordinates of cells with value 1 and output them in a matrix celcordmat
        cellcoords.matrixcalc(summat, celcordmat);
        //get the size of the celcordmat matrix
        currentdim = celcordmat.dim;
        //get values from all the celcordmat matrix cells, call them targets and connect them with probes with jit.gl.sketch
        for (n = 0; n < currentdim; n++)
{
     target = celcordmat.getcell (n);
     targetvalue = particlemat.getcell(target);
     sketch.linesegment(probe, targetvalue);
     }
}
}