Qfyilyi

The following code generates random points(x,y) and then for each point it splits the canvas (one square) into four. With the next point in the iteration it searches for the square where the point is located and splits it into four smaller squares - up to a certain square size.

The problem is it is very fast to run in Chrome and extremely slow in Ps (for 11k points it takes 2 seconds in Chrome and 30 minutes in Ps! For 1k points it takes around 10 secs in Ps.

Is there any better rewriting to this? btw, Ps doesn't support ES5

var squares = ;

var canvaswidth = app.activeDocument.width.as("px");

var canvasheight = app.activeDocument.height.as("px");

squares.push([{

    x: 0,

    y: 0

}, {

    x: canvaswidth,

    y: 0

}, {

    x: canvaswidth,

    y: canvasheight

}, {

    x: 0,

    y: canvasheight

}])

vertices = ;

for (i = 0; i < 8000; i++) {

    vertices.push({

        x: Math.floor(Math.random() * canvaswidth),

        y: Math.floor(Math.random() * canvasheight)

    })

}

var t0 = new Date().getTime();

var minsquaresize = 24;

for (v = 0; v < vertices.length; v++) {

    if (v > 0 && Math.abs(vertices[v].x - vertices[v - 1].x) > minsquaresize && Math.abs(vertices[v].y - vertices[v - 1].y) > minsquaresize) {

        r = 2;



           for (s = 0; s < squares.length; s++) {



            var squares_s = squares[s];

            if (squares_s != undefined && vertices[v].x >= squares_s[0].x && vertices[v].x <= squares_s[2].x && vertices[v].y >= squares_s[0].y && vertices[v].y <= squares_s[2].y && squares_s[1].x - squares_s[0].x > minsquaresize && squares_s[3].y - squares_s[0].y > minsquaresize) {

                var s1p1 = {

                    x: Math.round(squares_s[0].x),

                    y: Math.round(squares_s[0].y)

                };

                var s1p2 = {

                    x: Math.round((squares_s[0].x + squares_s[1].x) / 2),

                    y: Math.round((squares_s[0].y + squares_s[1].y) / 2)

                };

                var s1p3 = {

                    x: Math.round(((squares_s[1].x - squares_s[0].x) / r) + squares_s[0].x),

                    y: Math.round(((squares_s[3].y - squares_s[0].y) / r) + squares_s[0].y)

                }

                var s1p4 = {

                    x: (squares_s[0].x + squares_s[3].x) / 2,

                    y: Math.round((squares_s[0].y + squares_s[3].y) / 2)

                }

                var s2p2 = {

                    x: squares_s[1].x,

                    y: squares_s[1].y

                }

                var s2p3 = {

                    x: Math.round((squares_s[1].x + squares_s[2].x) / 2),

                    y: Math.round((squares_s[1].y + squares_s[2].y) / 2)

                }

                var s3p3 = {

                    x: squares_s[2].x,

                    y: squares_s[2].y

                }

                var s3p4 = {

                    x: Math.round((squares_s[2].x + squares_s[3].x) / 2),

                    y: Math.round(Math.round((squares_s[2].y + squares_s[3].y) / 2))

                }

                var s4p4 = {

                    x: squares_s[3].x,

                    y: squares_s[3].y

                }

                //alert(s4p4.y)

                delete squares[s];

                squares.push([s1p1, s1p2, s1p3, s1p4])

                squares.push([s1p2, s2p2, s2p3, s1p3])

                squares.push([s1p3, s2p3, s3p3, s3p4])

                squares.push([s1p4, s1p3, s3p4, s4p4])

                break;

            }

        }

    }

}

var t1 = new Date().getTime() - t0;

alert("time: "+t1)

Managed a significant performance increase by looping the squares in reverse.
So normally it was:

for(vertices length, v++){

 for(squares length, s++){

   if vertex is within square then delete square from square array, split square into 4 equal squares and add them to array

 }

}

Vertices are collected from a path, so vertex 4 will probably be close to vertex 3 so probably in the area of the last squares created from vertex 3 - in the end of the squares array. So:

for(var s = squares.length; s--;){...}

This works much faster (maybe 10 times). Strange that it is also faster with randomly placed vertices.