Collision Detection Problems with b2ContactEdge and b2Distance

[nocholasrift]

Hi there! I am currently working with the author of mvsim: https://github.com/MRPT/mvsim, which is a robot simulator which uses Box2D for collision detection. Box2D works great for preventing objects from penetrating each other. However, when we try to set a flag to true to expose this collision to the user, the behavior is inconsistent. Specifically, the problem seems to happen mostly when two edges are face to face (parallel), but occasionally happens for corner edges.

Current there are two techniques used to detect collision:

1. b2ContactEdge->contact->isTouching()
2. b2Distance() with the fixtures -- it works great sometimes, others it returns a large distance, even if the two bodies are face to face with two edges colliding.

Here is a link to the issue in which we are discussing this problem: MRPT/mvsim#42

Any help would be greatly appreciated! Is there a better way to detect collisions than this method?

Attached below is the dump file as requested as a follow up from my Discord post, where the robot crashed head on into an obstacle, and using both 1 and 2 failed to detect the collision:
box2d_dump.zip

[erincatto]

Are calling b2Distance directly? I need the data you are sending to that specific function. The world dump doesn't give me the data you send to that function. You'll have to print the input yourself somehow.

I'm guessing you increased b2_maxPolygonVertices? But looking at your geometry it doesn't seem necessary. Also you are creating 514 joints between static bodies.

[nocholasrift]

Is there some cleaner way to accomplish this printout of the data other than going through the docs and printing every member of every struct and class used? This is the code being used to try and detect the collisions, would I be trying to print all the fields relevant to dO, dc, and di?

// Instantaneous collision flag:
isInCollision_ = false;
if (b2ContactEdge* cl = b2dBody_->GetContactList(); cl != nullptr)
{
	for (auto contact = cl->contact; contact != nullptr;
		 contact = contact->GetNext())
	{
		// We may store with which other bodies it's in collision?
		const auto shA = cl->contact->GetFixtureA()->GetShape();
		const auto shB = cl->contact->GetFixtureB()->GetShape();
		if (cl->contact->GetFixtureA()->IsSensor()) continue;
		if (cl->contact->GetFixtureB()->IsSensor()) continue;

		b2DistanceInput di;
		di.proxyA.Set(shA, 0 /*index for chains*/);
		di.proxyB.Set(shB, 0 /*index for chains*/);
		di.transformA =
			cl->contact->GetFixtureA()->GetBody()->GetTransform();
		di.transformB =
			cl->contact->GetFixtureB()->GetBody()->GetTransform();
		di.useRadii = true;

		b2SimplexCache dc;
		dc.count = 0;
		b2DistanceOutput dO;
		b2Distance(&dO, &dc, &di);

		if (dO.distance < simulable_parent_->collisionThreshold() ||
			cl->contact->IsTouching())
			isInCollision_ = true;
	}
}

[erincatto]

Set a breakpoint before the call to b2Distance, then in the watch window put in di, expand it and then copy the values. You should also list the proxy vertices.

Here is some example data I captured in Visual Studio.

-		distanceInput	{proxyA={m_buffer=0x000000eb168fee90 {{...}, {...}} m_vertices=0x000000eb168ff1d0 {x=-4.00000000 y=1.00000000 } ...} ...}	b2DistanceInput
-		proxyA	{m_buffer=0x000000eb168fee90 {{x=-4.00000000 y=1.00000000 }, {x=-5.00000000 y=5.00000000 }} m_vertices=...}	b2DistanceProxy
+		m_buffer	0x000000eb168fee90 {{x=-4.00000000 y=1.00000000 }, {x=-5.00000000 y=5.00000000 }}	b2Vec2[2]
+		m_vertices	0x000000eb168ff1d0 {x=-4.00000000 y=1.00000000 }	const b2Vec2 *
		m_count	2	int
		m_radius	0.00999999978	float
-		proxyB	{m_buffer=0x000000eb168feeb0 {{x=-107374176. y=-107374176. }, {x=-107374176. y=-107374176. }} m_vertices=...}	b2DistanceProxy
+		m_buffer	0x000000eb168feeb0 {{x=-107374176. y=-107374176. }, {x=-107374176. y=-107374176. }}	b2Vec2[2]
+		m_vertices	0x000002a0fdb64c70 {x=0.00000000 y=0.00000000 }	const b2Vec2 *
		m_count	1	int
		m_radius	1.00000000	float
-		transformA	{p={x=0.00000000 y=0.00000000 } q={s=0.00000000 c=1.00000000 } }	b2Transform
+		p	{x=0.00000000 y=0.00000000 }	b2Vec2
+		q	{s=0.00000000 c=1.00000000 }	b2Rot
-		transformB	{p={x=-3.27151895 y=6.73861551 } q={s=0.00000000 c=1.00000000 } }	b2Transform
+		p	{x=-3.27151895 y=6.73861551 }	b2Vec2
+		q	{s=0.00000000 c=1.00000000 }	b2Rot
		useRadii	false	bool
-		distanceInput.proxyA.m_vertices,2	0x000000eb168ff1d0 {{x=-4.00000000 y=1.00000000 }, {x=-5.00000000 y=5.00000000 }}	const b2Vec2[2]
+		[0]	{x=-4.00000000 y=1.00000000 }	const b2Vec2
+		[1]	{x=-5.00000000 y=5.00000000 }	const b2Vec2
-		distanceInput.proxyB.m_vertices,1	0x000002a0fdb64c70 {{x=0.00000000 y=0.00000000 }}	const b2Vec2[1]
+		[0]	{x=0.00000000 y=0.00000000 }	const b2Vec2

[nocholasrift]

@erincatto Apologies for the delay, here is a a dump of what was contained in di right before the function call. Is the nan value I'm seeing in the proxyA m_buffer to blame? The setup is same as before, there is a head on collision between the robot and the obstacle, but the current way the box2D api is being used isn't detecting any collision (last if statement in code provided above is false).

	Locals		
		angle	0	float
		cl	@0x555555c7f8e0	b2ContactEdge
		contact	@0x555555c7f8a0	b2Contact
		context	@0x7fffffffdf60	mvsim::TSimulContext &
		dO	@0x7fffffffddd0	b2DistanceOutput
		dc	@0x7fffffffddf4	b2SimplexCache
		di	@0x7fffffffde00	b2DistanceInput
			proxyA	@0x7fffffffde00	b2DistanceProxy
				m_buffer	@0x7fffffffde00	b2Vec2[2]
					[0]	@0x7fffffffde00	b2Vec2
						x	nan	float
						y	4.591634678053128e-41	float
					[1]	@0x7fffffffde08	b2Vec2
						x	34816179306496.0	float
						y	3.061136495317563e-41	float
				m_count	4	int32
				m_radius	0.00999999978	float
				m_vertices	@0x555555d56b08	b2Vec2
					x	0.0299999937	float
					y	0.144999996	float
			proxyB	@0x7fffffffde20	b2DistanceProxy
				m_buffer	@0x7fffffffde20	b2Vec2[2]
					[0]	@0x7fffffffde20	b2Vec2
					[1]	@0x7fffffffde28	b2Vec2
				m_count	14	int32
				m_radius	0.00249999994	float
				m_vertices	@0x555555fb9938	b2Vec2
					x	0.0769287646	float
					y	0	float
			transformA	@0x7fffffffde40	b2Transform
				p	@0x7fffffffde40	b2Vec2
					x	-3.195467	float
					y	5.40175343	float
				q	@0x7fffffffde48	b2Rot
					c	-0.851679325	float
					s	0.524063289	float
			transformB	@0x7fffffffde50	b2Transform
				p	@0x7fffffffde50	b2Vec2
					x	-3.67499995	float
					y	5.4749999	float
				q	@0x7fffffffde58	b2Rot
					c	1	float
					s	0	float
			useRadii	true	bool
		lck	@0x7fffffffdd80	std::unique_lock<std::shared_mutex>
		pos	@0x555555f45f2c	b2Vec2 &
		shA	@0x555555d56af0	b2Shape
		shB	@0x555555fb9920	b2Shape
		this	@0x555555fd76d0	mvsim::Block
		vel	@0x555555f45f60	b2Vec2 &
		w	0	float
	Inspector		
	Expressions		
	Return Value		
	Tooltip