How to "translate" the Midpoint Circle Algorithm into matplotlib?

Question

I need to implement the Midpoint Circle Algorithm in matplotlib, so that a circle is rasterized on a square grid of 200x200 cells. Please also refer to my other question on the subject.

Thanks to this answer, I was able to find some code which I assume works flawlessly. My only problem is that I wouldn't know how to integrate it and amend it to make sure matplotlib draws a filled circle with 1 inside and 0 outside.

This is how I implement the script with matplotlib:

import numpy
import matplotlib.pyplot as plt    
n=200 #Grid size, 4 times my visualized output in order to be able to truncate some circles
empty_lattice=numpy.zeros((n,n)) #The empty 2D grid
radius=int(numpy.random.uniform(30,90)) #Radius
xc=int(numpy.random.uniform(0,n-radius)) #X center
yc=int(numpy.random.uniform(0,n-radius)) #Y center
x=0
y=radius
d=3-2*radius
while (x<=y):
    for hor in range(0,x): #This loop is my unfortunate attempt to fill the circle with 1s
        for ver in range(0,y):
            empty_lattice[xc+x][yc+y]=1 #1st octant
            empty_lattice[xc-x][yc+y]=1 #2nd octant
            empty_lattice[xc+x][yc-y]=1 #3rd octant
            empty_lattice[xc-x][yc-y]=1 #4th octant
            empty_lattice[xc+y][yc+x]=1 #5th octant
            empty_lattice[xc-y][yc+x]=1 #6th octant
            empty_lattice[xc+y][yc-x]=1 #7th octant
            empty_lattice[xc-y][yc-x]=1 #8th octant
    if (d<0):
        d=d+4*x+6
    else:
        d=d+4*(x-y)+10
        y=y-1
    x=x+1

Now, this is what I obtain, but you see that my circle is empty and that there is a "gap" in the horizontal line at the bottom of it. This gap occurs at each octant intersection. How can I amend my code to fill the circle and the gap?

EDIT

After having adopted the answer provided below, I have realized that two mirrored circles are drawn in the image below. I think this bug came with my original script and not with the answer. I only want one circle in each image. How can I get rid of this feature?

You might want to look at `skimage` which has a set of tools that take care of this sort of thing for you. If you want to do it your self, I strongly suspect that doing this with broadcasting will be effectively faster (by letting numpy do the loops in c instead of doing them your self in python). — tacaswell, Feb 21 '16 at 22:41

Jeff Irwin · Accepted Answer · 2016-02-21T21:08:59.703

To get rid of the gap, you need to extend the horizontal range by one. In your code, that would be the line for hor in range(0,x + 1):. My code takes a different strategy.

As far as I understand it, the midpoint circle algorithm just walks around the perimeter of the circle. So I don't think it can be easily modified to fill the interior. The code below checks every point in the first octant to see if the point's distance from the center is less than or equal to the radius. If it is within the radius, then all 8 corresponding points in each octant are filled.

import numpy
import matplotlib.pyplot as plt    
n=200 #Grid size, 4 times my visualized output in order to be able to truncate some circles
empty_lattice=numpy.zeros((n,n)) #The empty 2D grid
radius=int(numpy.random.uniform(30,90)) #Radius
xc=int(numpy.random.uniform(0,n-radius)) #X center
yc=int(numpy.random.uniform(0,n-radius)) #Y center
r2 = radius ** 2
for dx in range(0, radius):
    dx2 = dx ** 2
    for dy in range(0, dx + 1):
        dy2 = dy ** 2
        if (dx2 + dy2 <= r2):
            empty_lattice[xc+dx][yc+dy]=1 #1st octant
            empty_lattice[xc-dx][yc+dy]=1 #2nd octant
            empty_lattice[xc+dx][yc-dy]=1 #3rd octant
            empty_lattice[xc-dx][yc-dy]=1 #4th octant
            empty_lattice[xc+dy][yc+dx]=1 #5th octant
            empty_lattice[xc-dy][yc+dx]=1 #6th octant
            empty_lattice[xc+dy][yc-dx]=1 #7th octant
            empty_lattice[xc-dy][yc-dx]=1 #8th octant

plt.imshow(empty_lattice)
plt.show()

If you really want to stick with the midpoint circle algorithm, you could draw the perimeter, then start a flood fill from the center point.

Edit 1:

Got rid of two unnecessary lines.

Edit 2:

The above code wraps the circle around the image edges in a modular fashion. If you don't want that, some extra conditions are needed:

            empty_lattice[xc+dx][yc+dy]=1 #1st octant
            if (xc - dx >= 0):
                empty_lattice[xc-dx][yc+dy]=1 #2nd octant
            if (yc - dy >= 0):
                empty_lattice[xc+dx][yc-dy]=1 #3rd octant
            if (xc - dx >= 0 and yc - dy >= 0):
                empty_lattice[xc-dx][yc-dy]=1 #4th octant
            if (yc + dx < n):
                empty_lattice[xc+dy][yc+dx]=1 #5th octant
            if (xc - dy >= 0):
                empty_lattice[xc-dy][yc+dx]=1 #6th octant
            if (yc - dx >= 0):
                empty_lattice[xc+dy][yc-dx]=1 #7th octant
            if (xc - dy >= 0 and yc - dx >= 0):
                empty_lattice[xc-dy][yc-dx]=1 #8th octant

Edit 3:

I realized what was wrong with your original code. Your for loop involved a variable hor, but you forgot to use hor. This code works. I'll leave it up to you to check that the indices are positive.

x=0
y=radius
d=3-2*radius
while (x<=y):
    for hor in range(0,x + 1): #This loop is my unfortunate attempt to fill the circle with 1s
##        for ver in range(0,y):
        empty_lattice[xc+hor][yc+y]=1 #1st octant
        empty_lattice[xc-hor][yc+y]=1 #2nd octant
        empty_lattice[xc+hor][yc-y]=1 #3rd octant
        empty_lattice[xc-hor][yc-y]=1 #4th octant
        empty_lattice[xc+x][yc+hor]=1 #1st octant
        empty_lattice[xc-x][yc+hor]=1 #2nd octant
        empty_lattice[xc+x][yc-hor]=1 #3rd octant
        empty_lattice[xc-x][yc-hor]=1 #4th octant
        empty_lattice[xc+hor][yc+x]=1 #5th octant
        empty_lattice[xc-hor][yc+x]=1 #6th octant
        empty_lattice[xc+hor][yc-x]=1 #7th octant
        empty_lattice[xc-hor][yc-x]=1 #8th octant
        empty_lattice[xc+y][yc+hor]=1 #5th octant
        empty_lattice[xc-y][yc+hor]=1 #6th octant
        empty_lattice[xc+y][yc-hor]=1 #7th octant
        empty_lattice[xc-y][yc-hor]=1 #8th octant
    if (d<0):
        d=d+4*x+6
    else:
        d=d+4*(x-y)+10
        y=y-1
    x=x+1

I'd be interested in knowing which one of the two approaches - the flood fill and this modified midpoint circle algorithm - is faster. Any insights? — FaCoffee, Feb 21 '16 at 20:22
I think the flood fill would be slightly faster. I'm not sure if you noticed, but your original code draws the edge just fine if you comment out the two `for` loops and un-indent the `empty_lattice` assignment. The flood fill would not need to calculate distances, but I don't think the extra programming effort is worth it. — Jeff Irwin, Feb 21 '16 at 20:32
@FC84 See edit 2. However, your comment indicates that your grid size is 4 times your visualized output. So you could just visualize the 1: 100 quarter instead of using all those clunky `if` statements. — Jeff Irwin, Feb 21 '16 at 20:54
I do that further down the line in my script. But I seem to understand I could get rid of some of the if statements, right? — FaCoffee, Feb 21 '16 at 20:56
Ah yes. It's been a while since I did Python programming, and I almost forgot about the negative index feature. You only need to check that they're positive, not that they're less than `n`. — Jeff Irwin, Feb 21 '16 at 21:04

How to "translate" the Midpoint Circle Algorithm into matplotlib?

1 Answers1