Algorithm of resizing rectangles but keeping the distances between them - algorithm

Question

i am looking for an algorithm that will resize all rectangles to new width, height of all objects on the scene but keep the distances between them. Is that possible ?
The anchor for each rectangle is Top-Left (0,0). Thank you.

Answer 1

I have found the algorithm, not sure if its the best or optimized.
Basically finding depths and then sorting but depth adding extra or x multiplied by depth. The algorithm should be applied for Y as well.
1.First get the most left unmarked element. (mark when make depths)
2.Find all siblings top/bottom (sibling element which is from pos.x-width to pos.x+width)
3.Mark elements depth.
4.Repeat
Using stacks instead of recursion code is not completely DRY.
vt.iccode.DrawScene.prototype.ClearDepths = function () {
for (var i=0,ii=this.nodes.length;i<ii;i++) {
var node = this.nodes[i];
node.ClearDepths();
}
};
/*
* #private
*/
vt.iccode.DrawScene.prototype.MarkTopSiblings = function(node_start, depth) {
var stack = new Array();
stack.push(node_start);
while (stack.length > 0) {
var node = stack[stack.length - 1];
stack.splice(stack.length - 1, 1);
console.info("marking top :"+node.name+" depth ->"+depth);
node.depth_x = depth;
var pos = node.GetPosition();
var size = node.GetSize();
var next_node = this.GetClosestElementWithinBounds(node, pos.x - size.width, pos.x + size.width, Number.NEGATIVE_INFINITY, pos.y);
if (next_node) {
stack.push(next_node);
}
}
};
vt.iccode.DrawScene.prototype.MarkBottomSiblings = function(node_start, depth) {
var stack = new Array();
stack.push(node_start);
while (stack.length > 0) {
var node = stack[stack.length - 1];
stack.splice(stack.length - 1, 1);
console.info("marking bottom :"+node.name+" depth ->"+depth);
node.depth_x = depth;
var pos = node.GetPosition();
var size = node.GetSize();
var next_node = this.GetClosestElementWithinBounds(node, pos.x - size.width, pos.x + size.width, pos.y + size.height, Number.POSITIVE_INFINITY);
if (next_node) {
stack.push(next_node);
}
}
};
vt.iccode.DrawScene.prototype.GetMostLeftUnmarked = function() {
var s_x = Number.POSITIVE_INFINITY;
var best_match = null;
for (var i=0,ii=0;i<this.nodes.length;i++) {
var node = this.nodes[i];
var pos = node.GetPosition();
if (goog.isNull(node.depth_x) && pos.x < s_x) {
s_x = pos.x;
best_match = node;
}
}
return best_match;
};
vt.iccode.DrawScene.prototype.GetClosestElementWithinBounds = function(node, x_min, x_max, y_min, y_max) {
var found = new Array();
for (var i = 0, ii = this.nodes.length; i < ii; i++) {
var node_test = this.nodes[i];
var pos = node_test.GetPosition();
if (pos.x >= x_min && pos.x <= x_max && pos.y >= y_min && pos.y <= y_max && goog.isNull(node_test.depth_x) && goog.isNull(node_test.depth_y)) {
found.push(node_test);
}
}
var s_distance = Number.POSITIVE_INFINITY;
var best_match = null;
for (var i = 0, ii = found.length; i < ii; i++) {
var node_test = found[i];
var dist = node.FindDistanceBetweenAnchorPoints(node_test);
if (dist < s_distance) {
s_distance = dist;
best_match = node_test;
}
}
;
return best_match;
};
Use like :
this.ClearDepths();
var most_left_node = this.nodes[0];
var stack = new Array();
stack.push(most_left_node);
var depth_x = 0;
while(stack.length>0) {
var node = stack[stack.length - 1];
stack.splice(stack.length - 1, 1);
this.MarkBottomSiblings(node,depth_x);
this.MarkTopSiblings(node, depth_x);
var node_next = this.GetMostLeftUnmarked();
if (!goog.isNull(node_next)) {
//
console.info(node_next.name);
stack.push(node_next);
// return;
}
depth_x++;
}
After we know the depths we can move by x vise versa for y.