Creating anti-aliased circular mask efficiently

Question

I am trying to create anti-aliased (weighted and not boolean) circular masks for making circular kernels for use in convolution.

radius = 3  # no. of pixels to be 1 on either side of the center pixel
            # shall be decimal as well; not the real radius
kernel_size = 9                
kernel_radius = (kernel_size - 1) // 2
x, y = np.ogrid[-kernel_radius:kernel_radius+1, -kernel_radius:kernel_radius+1]
dist = ((x**2+y**2)**0.5)
mask = (dist-radius).clip(0,1)
print(mask)

and the output is

array([[1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  ],
       [1.  , 1.  , 0.61, 0.16, 0.  , 0.16, 0.61, 1.  , 1.  ],
       [1.  , 0.61, 0.  , 0.  , 0.  , 0.  , 0.  , 0.61, 1.  ],
       [1.  , 0.16, 0.  , 0.  , 0.  , 0.  , 0.  , 0.16, 1.  ],
       [1.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 1.  ],
       [1.  , 0.16, 0.  , 0.  , 0.  , 0.  , 0.  , 0.16, 1.  ],
       [1.  , 0.61, 0.  , 0.  , 0.  , 0.  , 0.  , 0.61, 1.  ],
       [1.  , 1.  , 0.61, 0.16, 0.  , 0.16, 0.61, 1.  , 1.  ],
       [1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  ]])

Then we can do

mask = 1 - mask
print(mask)

to get

array([[0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  ],
       [0.  , 0.  , 0.39, 0.84, 1.  , 0.84, 0.39, 0.  , 0.  ],
       [0.  , 0.39, 1.  , 1.  , 1.  , 1.  , 1.  , 0.39, 0.  ],
       [0.  , 0.84, 1.  , 1.  , 1.  , 1.  , 1.  , 0.84, 0.  ],
       [0.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 1.  , 0.  ],
       [0.  , 0.84, 1.  , 1.  , 1.  , 1.  , 1.  , 0.84, 0.  ],
       [0.  , 0.39, 1.  , 1.  , 1.  , 1.  , 1.  , 0.39, 0.  ],
       [0.  , 0.  , 0.39, 0.84, 1.  , 0.84, 0.39, 0.  , 0.  ],
       [0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  , 0.  ]])

I can now normalize and use this as my circular filter (kernel) in convolution operations.

Note: Radius can be decimal. Eg: get_circular_kernel(0.5,(5,5)) should give

array([[0.        , 0.        , 0.        , 0.        , 0.        ],
       [0.        , 0.08578644, 0.5       , 0.08578644, 0.        ],
       [0.        , 0.5       , 1.        , 0.5       , 0.        ],
       [0.        , 0.08578644, 0.5       , 0.08578644, 0.        ],
       [0.        , 0.        , 0.        , 0.        , 0.        ]])

I want to generate a million of these at the very least, with the kernel_size fixed and radius changing, so is there a better or more efficient way to do this? (maybe without costly operations like sqrt and still stay accurate enough to arc integrals i.e., area covered by the curve in the particular pixel?)

Could you please be more specific about what you mean by "better"? In other words, in what ways does your current solution not meet your needs? — NPE, Jun 23 '18 at 16:27
Also, are these values from this method accurate enough? how do I cross-check if these values are accurate (as in, the value `0.39` should mean that 39% of the pixel area was covered by the curve on that pixel)? — Saravanabalagi Ramachandran, Jun 23 '18 at 16:27
Again, "accurate enough" is vague (enough for what?) However, it's pretty clear that the diameter of your circle at the horizontal and vertical axes is 7 (just count the ones). If the code were accurate, the diameter would be twice the radius, i.e. 6, and not 7. — NPE, Jun 23 '18 at 16:32
https://stackoverflow.com/questions/485800/algorithm-for-drawing-an-anti-aliased-circle — NPE, Jun 23 '18 at 16:37
I suspect that your way is actually pretty good and efficient. You could try to use some [jit-compiler](https://stackoverflow.com/a/49011917/997253) like `numba` which might speed it up. — Andreas Storvik Strauman, Jun 24 '18 at 10:48

Andras Deak -- Слава Україні · Accepted Answer · 2018-06-25T10:26:32.093

2

Since you want to generate a large number of kernels with the same size, you can greatly improve performance by constructing every kernel in one step rather than one after the other in a loop. You can create a single array of shape (num_radii, kernel_size, kernel_size) given num_radii values for each kernel. The price of this vectorization is memory: you'll have to fit all these values in RAM, otherwise you should chunk up your millions of radii into a handful of smaller batches and generate each batch again separately.

The only thing you need to change is to take an array of radii (rather than a scalar radius), and inject two trailing singleton dimensions so that your mask creation triggers broadcasting:

import numpy as np 

kernel_size = 9
kernel_radius = (kernel_size - 1) // 2
x, y = np.ogrid[-kernel_radius:kernel_radius+1, -kernel_radius:kernel_radius+1]
dist = (x**2 + y**2)**0.5 # shape (kernel_size, kernel_size)

# let's create three kernels for the sake of example
radii = np.array([3, 3.5, 4])[...,None,None] # shape (num_radii, 1, 1)
# using ... allows compatibility with arbitrarily-shaped radius arrays

masks = 1 - (dist - radii).clip(0,1) # shape (num_radii, kernel_size, kernel_size)

Now masks[0,...] (or masks[0] for short, but I prefer the explicit version) contains the example mask in your question, and masks[1,...] and masks[2,...] contain the kernels for radii 3.5 and 4, respectively.

edited Jun 25 '18 at 10:26

answered Jun 24 '18 at 18:02

Andras Deak -- Слава Україні

33,737
11
83
111

1

it should be `[..., None, None]` so it works for 2D numpy arrays as well. If it is `(2,2)` then `[:, None, None]` would give `(2,1,1,2)`, but we want `(2,2,1,1)` – Saravanabalagi Ramachandran Jun 25 '18 at 08:46
`for` loop was swallowing so much time, but this **one shot** thingy is incomparably faster... – Saravanabalagi Ramachandran Jun 25 '18 at 09:09
For one million `(9,9)` kernels with `for` loop `16.4s` with one shot `0.6s`. Also, I combined the in-place operations as suggested by [J. Martinot-Lagarde](https://stackoverflow.com/a/51011793/3125070) and that further sped up from `0.6s` to `0.5s` – Saravanabalagi Ramachandran Jun 25 '18 at 09:14
Yes, if you want all the masks at once this solution is better. – J. Martinot-Lagarde Jun 25 '18 at 09:44
@SaravanabalagiRamachandran indeed, thanks, I updated with the ellipsis. I had a simple 1d array `radii` in mind, but of course it can't hurt to be more general; actually the updated version allows arrays of any shape for `radii`. – Andras Deak -- Слава Україні Jun 25 '18 at 10:27

J. Martinot-Lagarde · Answer 2 · 2018-06-24T19:46:49.030

If you want to build millions of masks, you should precompute once what never changes, and compute only the strict necessary for each radius.

You can try something like this:

class Circle:
    def __init__(self, kernel_size):
        self._kernel_size = kernel_size
        self._kernel_radius = (self._kernel_size - 1) // 2

        x, y = np.ogrid[
            -self._kernel_radius:self._kernel_radius+1,
            -self._kernel_radius:self._kernel_radius+1]
        self._dist = np.sqrt(x**2 + y**2)

    def __call__(self, radius):
        mask = self._dist - radius
        mask = np.clip(mask, 0, 1, out=mask)
        mask *= -1
        mask += 1
        return mask


circle = Circle(kernel_size=9)
for radius in range(1, 4, 0.2):
    mask = circle(radius)  
    print(mask)

I did the operations inplace as much as possible to optimize for speed and memory, but for small arrays it won't matter much.

oh, sorry but radius shall be used as the main param here and it could be in decimals, hence not restricted to only 5 different masks, updated the question and the answer :) — Saravanabalagi Ramachandran, Jun 24 '18 at 17:06
I understand better now, thanks for the update. The integer division for the radius was misleading ;) The stop value for range is wrong now, I'll update it. — J. Martinot-Lagarde, Jun 24 '18 at 19:46

Creating anti-aliased circular mask efficiently

2 Answers2

Linked