vector2d | Operates using Objects | Machine Learning library

You can convert cartesian coordinates (x, y) into polar ones (R, fi), add theta to fi and then convert back to cartesian:

That looks right to me if you're wanting to stick with using Eigen.

Generally though since the polar representation has angles, it might be good to avoid using the Eigen::Vector2d just for the sake of reducing mistakes that may be made in the future (like adding multiple angles together and not dealing with the fact that 0 == 2*PI). Maybe you could do it with structs instead:

The computation of normalised_x and normalised_y is wrong. Normalized device coordinates are in range [-1.0, 1.0]:

in AddLabels method, vector points is const. setPointLabel is non-const member function. non-const member functions can only be invoked for non-const objects. Either

1. remove const from const vector &points , or
2. mark function setPointLabel const.

_mapNewPoints[it->first].insert would imply that Point has an insert method which is not the case. I believe you may want something like this:

The main problem is that you are letting the balls overlap each other, then update their velocities. However, if the next time step is shorter than the previous one, it can be that after updating their positions, they are still overlapping. Then you think they are colliding again, and update their velocities, but this will most likely cause then to move closer together again. This explains why they get stuck.

The proper wait to solve this is to calculate the exact point in time that two moving balls collide. This can be done analytically, for example by treating time as a third dimension, and then calculating a line-sphere intersection. If this happens during the time step, you advance the time up to the point that the collision happens, then update the velocities, and then perform the rest of the step. If you have more than two balls, then be aware that you can have more than two balls colliding all with each other in the same timestep. This is also solvable, just calculate all the time points that collisions happen, select the earliest one, update velocities at that point, and then recalculate the collision times, and so on until there are no collisions in the time step.

Your workaround might fix two balls sticking to each other, but the result is not physically accurate. It breaks down when you start increasing the density of balls, since at some point the chance will be very high that at least one ball of a pair that should collide was in a collision in the previous timestep, and then they will all just start passing through each other all the time.

Another issue is that you have to check every possible pair of balls in updateCanCollide(), which is not efficient. There is a simpler and more common workaround to this problem: when two balls collide, after updating their velocities, immediately update their positions as well such that the balls are no longer colliding. You can try to calculate exactly how much to move them so they no longer overlap, or if you don't want to involve mathematics, you can just have a while loop to do a small step until they no longer overlap.

Note that there are also some other thing in your code that you could improve:

• Don't new a temporary Vector2D, just declare it on the stack. If for some reason this is not possible, at least delete v1 and v2 afterwards.
• You don't need to call abs() if you are going to square the result anyway.
• Use std::hypot() to calculate the distance.
• Did you write Vector2D yourself or is it from a library? If the latter, maybe it already has functions to reflect two 2D vectors? If the former, consider using a library like GLM, even if you are not using OpenGL.
• Use a proper value of π. A simple, portable solution is to declare static constexpr pi = std::atan(1) * 4.

I have not found the best solution but for now I decided to use lambda functions:

You can use JOML (which is also downloadable as an LWJGL 3 Addon) and its Matrix4f.project() method for this. The following is a functioning port of your shown code snippet for LWJGL3 + JOML:

Virtual methods are instantiated in the same time than the class, so it should be correct.

You might provide 2 versions: