@Fereydoon_Shekofte 

To be honest, I'm not familiar with games at all. As for pixels, on the proposed basis, it is possible  to  solve the problem of finding approximate integer values to the curve. That is, we will need not integer solutions, as in the Diophantine equations, but the nearest integers to the coordinates of the current point of the curve at each step, in order to replace the real coordinates with integers.
After that, it is necessary, for example, by means of scaling, to correlate these integer coordinates with pixels. Thus, representing the curve as pixels.
But it seems to me that something like this is happening everywhere and for a long time, because we can perfectly see all our charts on the screens.

@Fereydoon_Shekofte   I need to think.

Example from Wikipedia.  2^n - 7 = x^2;
We immediately find all integer solutions (and the desired natural solutions in the same place):
(15, 181), (7, 11), (5, 5), (4, 3), (3, 1), (3, -1), (4, -3), (5, -5), (7, -11), (15, -181).
Because they all lie on the same continuous curve:

 

Examples of Diophantine solutions on spheres with a radius equal to an integer.

@mmcdara   I would love to show you my smile.

x1^2+2*x2^2+x3^2-x2*x3 -100=0;

Another example, but from 2d .
x2^3+x1^2-x1*x2-16=0;
In some seconds, the Method finds the following integer solutions:
(-33284, -1024), (-86, -18), (-60, -14), (-6, -2), (-4, 0), (-2, 2), (4, 0), (4, -2), (46, -14), (68, -18), (32260, -1024).

I think this is not bad for a numerical approach to Diophantine equations that works without enumeration of the coordinate grid.

@acer Thank you.

@acer  Sorry, but I have problems with English and with online translation. I didn't understand what you wanted to say. Just in case, I'll tell you what I did. I built graphs and saw that there are intersection points for all ns. Then I tried the NextZero function. From point 0, NextZero skips the solution for the first value of ns, so I moved the starting point to the right. This point, for example, can be either 1.*10^(-14) and 4.*10^(-10) ...

@C_R 
To be honest, I don't know much about joints. I think, for this scheme, the joints can be any suitable. And the L5 itself can be made of variable length due to the splined connection. It's just a mixer.
And it also seemed to me that in the pictures from the Internet, the "horns" holding the container (first picture) are made of springy plates that can compensate for small deformations.

@C_R 
The percentage of change in the length of L5 in a full cycle during the operation of the original program.

@C_R 
But I think it's all right. MapleSim works analytically and therefore cannot have deformation. In the proposed simulation, the mechanism is calculated numerically. If geometrically, then in one case the surfaces touch each other (when link lengths = a/sqrt(3)), and in the other case they intersect "shallowly".
(Visually L5 deforms a lot in your example. In the table (in the program text OF_experimental_1_part_3_Barrel.mw) these are hundredths of the length.)

@C_R 
Yes, only my the lower distance is not 2, but 2.4.  
If the distance is 2 and L1=2/sqrt(3), L5=1.35, then Maple also works fine, but the distortion is much stronger. Printed in program OF_experimental_1_part_3_Barrel.mw
If the distance is 2, and L1= 2/sqrt(3) and L5= 2/sqrt(3), then Maple throws an error and shows that the system of equations has no solutions. It is necessary to study the system with these data. It is possible that it has an infinite number of solutions and this will be the best option.

@C_R 
 

L1 := 1.6; L2 := 1.5; L5 := 1.35; 
f1 := (x7-g1)^2+(x8-g2)^2+(x9-g3)^2-L1^2; 
f2 := (x10-g1)^2+(x11-g2)^2+(x12-g3)^2-L1^2; 
f3 := (x1-CD1)^2+(x2-CD2)^2+(x3-CD3)^2-L1^2; 
f4 := (x4-CD1)^2+(x5-CD2)^2+(x6-CD3)^2-L1^2; 
f5 := (x4-x1)^2+(x5-x2)^2+(x6-x3)^2-L2^2; 
f6 := (x7-x10)^2+(x8-x11)^2+(x9-x12)^2-L2^2; 
f7 := ((x1+x4)*(1/2)-(x7+x10)*(1/2))^2+((x2+x5)*(1/2)-(x8+x11)*(1/2))^2+((x3+x6)*(1/2)-(x9+x12)*(1/2))^2-L5^2; 
f8 := (x10-x7)*(g2-x8)-(x11-x8)*(g1-x7); 
f12 := x4*(CD2-x2)-x5*(CD1-x1); 
f9 := (x1-x4)*(x7-x10)+(x2-x5)*(x8-x11)+(x3-x6)*(x9-x12); 
f10 := ((x7+x10)*(1/2)-(x1+x4)*(1/2))*(x4-x1)+((x8+x11)*(1/2)-(x2+x5)*(1/2))*(x5-x2)+((x9+x12)*(1/2)-(x3+x6)*(1/2))*(x6-x3); 
f11 := ((x7+x10)*(1/2)-(x1+x4)*(1/2))*(x10-x7)+((x8+x11)*(1/2)-(x2+x5)*(1/2))*(x11-x8)+((x9+x12)*(1/2)-(x3+x6)*(1/2))*(x12-x9); 
T := Isolate([f1, f2, f3, f4, f5, f6, f6, f7, f8, f9, f10, f11, f12], [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12])

L1 := 1.6 is the length of the levers; L2 := 1.5 is the width of the horns; L5 := 1.35 is the distance between the midpoints of the horns. And some of these parameters are printed (after calculations) in one of the given programs (in particular, L5). 
The system of equations itself gives 32 solutions, but it seems that there are only 4 fundamental provisions themselves. In other words, the system of equations does not contain free variables, and, accordingly, we do not have degrees of freedom of mechanism. Of course, we are talking about a specific mathematical model.But discarding f7, we formally get one degree of freedom, and with it a slight deformation of the "yellow" lever (in our case, L5)
To be honest, I made this mechanism out of curiosity. I was interested in testing exactly this approach. And this is where my knowledge ends.
If we talk about inverse kinematics, then I do not quite understand what "switching" is. But, I think that we can always replace the right construction (rhombus) with the left one. It is necessary to add equations corresponding to a rhombus to the mathematical model of the left device, and then the left device will work like a rhombus. That is, we virtually remove unnecessary degrees of freedom. This, of course, if I understand your question correctly.
I often look at the forum, but did not see your message, because the "flag" for me was not red. For this it is necessary. to have addressed to me. How do you now have a red flag.
Thanks again for your interest.

@C_R 
Yes, this method is equally suitable for both sequential and parallel manipulators, including the Stewart platform. We take the trajectory we need and solve the inverse problem.
(By the way, here on the forum at the end of the topic in the comments there is an example.)