Opacity and overlapping multiple polygons

Question

Let's say I have 100 polygons that are all different but most of them overlap. All I want to do is to draw/plot them in one single graphic with linearly adding gray values; i.e., a point with n overlapping polygons(or other graphics) should have a grayvalue of n/100.

I wish

Graphics[{Opacity[1/10], Table[Disk[{i/10, 0}], {i, 10}]}]

would work, but Opacity doesn't add up linearly, and I don't find any easy way to do what I want.

My current idea is to go via Image[Graphics[...]], ImageData and ArrayPlot, but I might lose a lot of precision that way.

Answer 1

I'm not very familiar with image-processing but I do not think you could get both, high precission and high performance, at once.

This is straightforward approach. With Image processing functions avalible in Mathematica. Also, I'm not going to use Opacity, I do not know how does it work inside.

First, there is a function to to create an image, you can set resulution like you need.

f = ColorConvert[Image[Graphics[#, PlotRange -> 1], 
                       "Bit", ImageResolution -> 96, ImageSize -> 500], 
                 "GrayScale"] &;

Lets create some triangles:

pics = f /@ (Polygon /@ Table[{{0, -1}, RandomReal[1, 2],RandomReal[{-1, 0}, 2]}, 
                              {100}]);

ImageMultiply[Fold[ImageAdd, First@pics, Rest@pics], 1/100]

Stealing examples with Disks (generating disk images last longer but not so much):

f = ColorConvert[Image[Graphics[#, PlotRange -> {{-1, 1}, {-.5, .5}}], "Bit", 
                       ImageResolution -> 96, ImageSize -> 500], "GrayScale"] &;

pics = f /@ Table[Disk[{-.5 + i/100, 0}, .5], {i, 100}];

ob = ImageMultiply[Fold[ImageAdd, First@pics, Rest@pics], 1/100]
ColorNegate@ob

As you can see, everything is linear:

ListPlot[ImageData[ColorNegate@ob][[ 130]]] 

Answer 2

In theory, the only way that overlaying $N$ objects with constant opacity will yield a completely opaque intersection is when $N \to \infty$. Therefore, it will be hard to get exactly what you want without resorting to image processing.

Here is a way to get the linear addition effect of intersecting gray-level objects using image tools:

With[{threshold = .05, n = 10},
 t = Table[
   Image[
    Graphics[
     {GrayLevel[threshold^(1/n)], Disk[{i/n, 0}]},
     PlotRange -> {{-1.1, 2.1}, {-1.1, 1.1}}
     ],
    ImageResolution -> 200
    ],
   {i, n}
   ];
 im = First[t //. {a___, x_, y_, b___} :> {a, ImageMultiply[x, y], b}];
 ImageApply[Log[Max[#, threshold]/threshold]/Log[1/threshold] &, im]]

Here I set n to be the number of overlapping shapes, and used your Disk example. The ImageResolution option can be used to your taste, to avoid the pixelated appearance you're worried about.

What I do is use ImageMultiply with a set of small GrayLevels for each shape. This is then subjected to ImageMultiply, leading initially to (undesirable) unequal steps in gray scale for the intersections. The darkest color that I can get with the multiplication of n shapes is set by threshold.

To get the threshold value to display as truly Black, I post-process the resulting multiplied images with ImageApply by taking the Log of the pixel values, to undo the exponentially varying GrayLevel of the individual intersecting shapes. The Log is scaled such that its result varies between 0 and 1.

By combining this geometric sequence of image gray levels with a Log, I end up with something that looks like addition of gray levels but achieves the full dynamic range between 0 and 1.

Answer 3

A simple approach, but perhaps not meeting your precision requirement, is to create the Graphics using Opacity as you did, and then use image processing to adjust the levels.

op = 1/10;
m = 10;
gr = Graphics[{Opacity[op], Table[Disk[{i/10, 0}], {i, 10}]}]

The gray level from combining $n$ layers of opacity $\text{op}$ is $\text{col}=(1-\text{op})^n$, so to convert to a gray level of $n/m$ requires:

ImageApply[Log[#]/(m Log[1 - op]) &, Image[gr]]

To confirm that the resulting image has a gray level of $n/10$:

ListPlot[ImageData[%][[130, All, 1]]]