Rendering thousands of points

Question

I am trying to render an image with some 120,000 Points. Technically it's just 10,000 points, plus their reflection, plus 5 rotations of both of those sets, but I'm not sure that's relevant. The code I'm using is something like this:

Graphics[
 {
   PointSize[1/n],
   White, 
   g = Point /@ Join @@ {points, points.{{1, 0}, {0, -1}}}, 
   Array[Rotate[g, Pi #/3, {0, 0}] &, 6]
 },
 Background -> Black,
 ImageSize -> n*p,
 ImageMargins -> n (1 - p)/2
]

where points contains 10,000 (integer) coordinate pairs.

A reasonably representative set of inputs would be

points = RandomInteger[{0, 10000}, {10000, 2}];
n = 600;
p = 0.8;

In reality, the points are created from a Brownian tree for this challenge over on PPCG.SE.

The problem is, I run out of memory. I don't actually need the resulting vector graphic, but wrapping the above in Rasterize doesn't help either (so I guess Mathematica does build the full vector graphic representation first anyway).

Is there a better way to rasterise a large number of points into an image? (Other than rounding all coordinates onto an n-by-n grid and using that as input to Image.)

Answer 1

Yves showed you how to shave off a factor of 10, and in the following I'll shave off another factor of 10.

First, the original code (plus some data of mine to make it work):

points = RandomReal[{0, 10}, {1000, 2}];

n = 500;
p = .99;

g1 = Graphics[{PointSize[1/n], White, 
   g = Point /@ Join @@ {points, points.{{1, 0}, {0, -1}}}, 
   Array[Rotate[g, Pi #/3, {0, 0}] &, 6]}, Background -> Black, 
  ImageSize -> n*p, ImageMargins -> n (1 - p)/2]

This takes more than 2 MB:

g1 // ByteCount

2468840

Using the trick Yves mentioned (Point@ instead of Point/@):

g2 = Graphics[{PointSize[1/n], White, 
    g = Point[Join @@ {points, points.{{1, 0}, {0, -1}}}], 
    Array[Rotate[g, Pi #/3, {0, 0}] &, 6]}, Background -> Black, 
   ImageSize -> n*p, ImageMargins -> n (1 - p)/2];

It saves a lot indeed:

g2 // ByteCount

232648

Now, since most of the pixels are rotated or reflected pixels ones, we can use the space saving function GeometricTransformation. If you use it with various transformations on a given Graphics object it doesn't store all the various transformed sets, but just the original set plus the transformations themselves, resulting in huge savings:

g3 = Graphics[{PointSize[1/n], White,
   GeometricTransformation[
    GeometricTransformation[
     Point@points,
     {
      TranslationTransform[{0, 0}],
      ReflectionTransform[{0, 1}]
      }
     ],
    {TranslationTransform[{0, 0}]}~Join~
     Array[RotationTransform[Pi #/3] &, 6]
    ]
   }, Background -> Black, ImageSize -> n*p, 
  ImageMargins -> n (1 - p)/2]

Indeed, this saves more than a factor of 10:

g3 // ByteCount

22448

Note that I used GeometricTransformation twice, once to get the original set plus its mirror image and once to rotate those two six times.

Obviously, given the different byte counts of g1, g2 and g3, their underlying graphics code must be different, but do we still get the same rasterized image?

Rasterize[g1] == Rasterize[g3]

True

Answer 2

One way to save memory is to use the multi-primitive syntax for Point (which should also render quite a bit faster)`:

coords = RandomReal[{-1, 1}, {1000, 2}];
Point /@ coords // ByteCount
Point@coords // ByteCount
%/%% // N

(*176200

  16552

  0.0939387*)

For your example you simply drop one character to save a whole lot (about 90%) of kernel real estate:

Graphics[{PointSize[1/n], White, 
   g = Point /@ Join @@ {points, points.{{1, 0}, {0, -1}}}, 
   Array[Rotate[g, Pi #/3, {0, 0}] &, 6]}, Background -> Black, 
  ImageSize -> n*p, ImageMargins -> n (1 - p)/2] // ByteCount

(*24642656*)

Graphics[{PointSize[1/n], White, 
   g = Point@Join @@ {points, points.{{1, 0}, {0, -1}}}, 
   Array[Rotate[g, Pi #/3, {0, 0}] &, 6]}, Background -> Black, 
  ImageSize -> n*p, ImageMargins -> n (1 - p)/2] // ByteCount

(*2244952*)

Also works a treat for Line or Polygon...