Drawing a line segment on a space that wraps toroidally - 2d

Question

I have a 2D space of angles [0, 2pi] x [0, 2pi] which wraps around, with toroid like topology (the horizontal edges correspond to each other, as do the vertical ones). I have two points in this space, and I would like to draw a line segment between those two points.
In some cases, this line segment is the obvious line segment, from one point to the other. In other cases, the line segment is supposed to "go around the edge" instead of going "the long way, through the middle":
+--------+
| |
| A--B |
| |
+--------+
+--------+
| |
|-A B-|
| |
+--------+
While these cases are moderately easy to handle, there is one case that is really vexing for me and which my code so far does not handle correctly:
+-----------+
| / |
| B |
| |
| A /|
| / / |
+-----------+
I.e. if the line wraps around both directions, it sometimes wraps around the opposite corner. I'm not entirely sure if there are more of these tricky cases.
The only algorithm I've come up that works reliably so far is to calculate the midpoint as (A + B) / 2 while making appropriate use of the modulo arithmetics, draw a dot at this position, and then recursively subdivide the left and right intervals similarly, until the distance between the dots is less than a single pixel. Obviously, this is not going to be very fast.
My other approach was to detect (separately for x and y) whether the short distance is direct or around the edge, and then either draw one line segment or two. This does not handle the third case correctly, unless the line is divided in two and the midpoint lies on the segment that is in the lower-right corner in the example image. I'm not sure how to detect this efficiently, or how to calculate the position of the midpoint, as simply the point in the half does not always work, it might end up at the edge together with one of the endpoints, if their respective distance from the edge is not equal.
Is there a better algorithm? Is there an obvious solution that I'm not seeing? I'm not even sure how to google for this problem. I don't want to implement my own line rasterization algorithm, I would just like to break this problem to Euclidean straight lines and draw these using OpenGL or GDI or whatever.
My code so far is:
void Draw_WrappedSegment(float f_x0, float f_y0, float f_x1, float f_y1)
{
const float s = 2 * f_pi;
f_x0 = fmod(fmod(f_x0, s) + s, s);
f_y0 = fmod(fmod(f_y0, s) + s, s);
f_x1 = fmod(fmod(f_x1, s) + s, s);
f_y1 = fmod(fmod(f_y1, s) + s, s);
// make sure the coordinates end up being positive and modulo 2pi
float f_ydist0 = fabs(f_y0 - f_y1);
float f_ydist1 = fabs(fmod(f_y0 + s - f_y1, s));
float f_ydist2 = fabs(fmod(f_y1 - f_y0 + s, s));
float f_xdist0 = fabs(f_x0 - f_x1);
float f_xdist1 = fabs(fmod(f_x0 + s - f_x1, s));
float f_xdist2 = fabs(fmod(f_x1 - f_x0 + s, s));
// 0 2pi 4pi
//p1'' | p0 p1 | p0' p1' |
// <---f_dist0--->
// <-f_dist1->
// <-f_dist2->
const float f_epsilon = 1e-3f; // sometimes the modulo causes an error and even though the díst 0 and dist 2 should equal, dist 2 is slightly smaller
if(f_xdist0 <= f_xdist1 + f_epsilon && f_xdist0 <= f_xdist2 + f_epsilon) {
if(f_ydist0 <= f_ydist1 + f_epsilon && f_ydist0 <= f_ydist2 + f_epsilon) {
MoveTo(f_x0, f_y0);
LineTo(f_x1, f_y1); // the "short" way in both directions
} else {
float f_sign = (f_y0 < f_y1)? 1 : -1; // swap the lower and upper edge if the points are not sorted by y
MoveTo(f_x0, f_y0);
LineTo(f_x1, f_y1 - f_sign * s); // from point 0 to the lower edge
MoveTo(f_x1, f_y1);
LineTo(f_x0, f_y0 + f_sign * s); // from point 1 to the upper edge
}
} else {
if(f_ydist0 <= f_ydist1 + f_epsilon && f_ydist0 <= f_ydist2 + f_epsilon) {
float f_sign = (f_x0 < f_x1)? 1 : -1; // swap the left and right edge if the points are not sorted by x
MoveTo(f_x0, f_y0);
LineTo(f_x1 - f_sign * s, f_y1); // from point 0 to the left edge
MoveTo(f_x1, f_y1);
LineTo(f_x0 + f_sign * s, f_y0); // from point 1 to the right edge
} else {
float f_sign_x = (f_x0 < f_x1)? 1 : -1; // swap the left and right edge if the points are not sorted by x
float f_sign_y = (f_y0 < f_y1)? 1 : -1; // swap the lower and upper edge if the points are not sorted by y
MoveTo(f_x0, f_y0);
LineTo(f_x1 - f_sign_x * s, f_y1 - f_sign_y * s); // from point 0 to one edge
MoveTo(f_x1, f_y1);
LineTo(f_x0 + f_sign_x * s, f_y0 + f_sign_y * s); // from point 1 to the other edge
}
}
}

Answer 1

Instead of working with just the square [0, 2pi] x [0, 2pi], try tiling the space [-2pi,4pi] x [-2pi,4pi] with nine copies of this square (like a tic-tac-toe board). Place A in the center square, and then place copies of B (translating the coordinates by ±2pi as required ) in each of the nine squares. Choose the copy of B that is closest to A, and then draw the line from A to that copy of B. This line may have more than one segment as it travels through the squares. Just "untranslate" these segments back to the central square and you will have the diagram you want.