Direct Collision Detection d3js

Question

I am trying to create collision detection in my formatted svg layout (d3js). I followed this tutorial, which causes conflict around the circle.

For some reason, it does not work for a rectangular shape. I tried to play with the parameters in the veil.

Here is my code:

 var node = svg.selectAll(".node") .data(json.nodes) .enter().append("g") .attr("class", "node") .call(force.drag); node .append("rect") .attr("class", "tagHolder") .attr("width", 60) .attr("height", 60) .attr("rx", 5) .attr("ry", 5) .attr("x", -10) .attr("y", -10); 

and this:

  svg.selectAll(".node") .attr("x", function(d) { return dx; }) .attr("y", function(d) { return dy; }); link.attr("x1", function(d) { return d.source.x; }) .attr("y1", function(d) { return d.source.y; }) .attr("x2", function(d) { return d.target.x; }) .attr("y2", function(d) { return d.target.y; }); node.attr("transform", function(d) { return "translate(" + dx + "," + dy + ")"; }); }); 

and collision function:

 function collide(node) { var r = 30, nx1 = node.x - r, nx2 = node.x + r, ny1 = node.y - r, ny2 = node.y + r; return function(quad, x1, y1, x2, y2) { if (quad.point && (quad.point !== node)) { var x = node.x - quad.point.x, y = node.y - quad.point.y, l = Math.sqrt(x * x + y * y), r = 30 + quad.point.radius; if (l < r) { l = (l - r) / l * .5; node.x -= x *= l; node.y -= y *= l; quad.point.x += x; quad.point.y += y; } } return x1 > nx2 || x2 < nx1 || y1 > ny2 || y2 < ny1; }; } 

How can I detect a collision for rect?

Thanks!!!

Answer 1

The collision function in example d3 calculates the overlap of circles by comparing the distance between their centers l = Math.sqrt(x * x + y * y) with the sum of their radii r = node.radius + quad.point.radius . When l < r circles overlap and the two circles move apart to correct the overlap.

A similar collision function for rectangles works the same way, calculating the overlap of rectangles and moving them apart:

 function collide(node) { var nx1, nx2, ny1, ny2, padding; padding = 32; nx1 = node.x - padding; nx2 = node.x2 + padding; ny1 = node.y - padding; ny2 = node.y2 + padding; return function(quad, x1, y1, x2, y2) { var dx, dy; if (quad.point && (quad.point !== node)) { if (overlap(node, quad.point)) { dx = Math.min(node.x2 - quad.point.x, quad.point.x2 - node.x) / 2; node.x -= dx; quad.point.x += dx; dy = Math.min(node.y2 - quad.point.y, quad.point.y2 - node.y) / 2; node.y -= dy; quad.point.y += dy; } } return x1 > nx2 || x2 < nx1 || y1 > ny2 || y2 < ny1; }; }; 

Overlay on the width dx = Math.min(node.x2 - quad.point.x, quad.point.x2 - node.x) / 2; where the overlap in height is dy = Math.min(node.y2 - quad.point.y, quad.point.y2 - node.y) / 2; , which shows that your nodes should know the two corners of the rectangle: the top left (x, y) and the bottom right (x2, y2) .

See the full example here: http://bl.ocks.org/dobbs/1d353282475013f5c156 . This example uses coffeescript and only moves the rectifiers away from each other along the y 'cos axis, which better matches what I need for my own case.