How to plot points in 2D without restricting their apparent positions to pixel grid?

Question

Compare the two renderings of the same point in the following code (this is just a reduced example, I know I could just zoom in the scene, it's not an option in original code):

Manipulate[Row[{
   Graphics[Point[{0, x[t]}], PlotRange -> {{-0.1, 0.1}, {-0.1, 0.3}},
     Axes -> False, ImageSize -> 10],
   Graphics3D[Point[{0, x[t], 0}], 
    PlotRange -> {{-0.1, 0.1}, {-0.1, 0.3}, All}, Boxed -> False, 
    ImageSize -> 10, ViewVector -> {0, 0, 10^4}]
   }], {t, 10, 100}, ControlPlacement -> Left, 
 Initialization :> (x[t_] = Abs@Sin[t]/t)]

The resulting two points animate like follows:

Here's a magnified version of the above animation to better see what happens:

You can see the point at left seems to move jerkily, while the one at right moves smoothly. After some time the left one stops moving, while the right one still does visibly move. This is due to antialiasing of positions, not just shape. 2D functions seem to round positions to integer screen coordinates, while 3D ones don't.

The second way with Graphics3D would be the best solution for me, but in some more complex 2D scenes the 3D engine takes too much time to render, making Manipulate unusable.

So my question is: is there any way to force 2D Graphics and functions like ListPlot antialias positions too, so that one didn't need to resort to 3D engine?

Answer 1

The obvious solution, if there's no native support for this in Mathematica, is to implement manual supersampling. Here's an example function which could do it:

antialias[img_, size_, supersampling_: 5] := ImageResize[Image[Rasterize[img,
    RasterSize -> supersampling*size], ImageSize -> supersampling*size], size]

The steps here are

1. Rasterize, which renders the image as it should look, but in a higher resolution,
2. Image, which creates actual image in the requested size (which Rasterize doesn't do),
3. ImageResize, which downsamples, applying some low-pass filter to the supersampled image.

If we omit step 1, then in various Plot, ListPlot etc. we'll get wrong sizes of points and lines. Rasterize makes them look correct.

Now we can include this variant in the demo from the OP as follows (the point rendered by the new method is in the middle):

Manipulate[Row[{
   Graphics[Point[{0, x[t]}], PlotRange -> {{-0.1, 0.1}, {-0.1, 0.3}},
     Axes -> False, ImageSize -> 10],
   antialias[Graphics[Point[{0, x[t]}], PlotRange -> {{-0.1, 0.1}, {-0.1, 0.3}},
     Axes -> False, ImageSize -> 10], 10],
   Graphics3D[Point[{0, x[t], 0}], 
    PlotRange -> {{-0.1, 0.1}, {-0.1, 0.3}, All}, Boxed -> False, 
    ImageSize -> 10, ViewVector -> {0, 0, 10^4}]
   }], {t, 10, 100}, ControlPlacement -> Left, 
 Initialization :> (
   x[t_] = Abs@Sin[t]/t;
   antialias[img_, size_, supersampling_: 5] := ImageResize[
     Image[Rasterize[img, RasterSize -> supersampling*size], 
      ImageSize -> supersampling*size], size]
   )]