# Efficient Algorithm to obtain Points in a Circle around a Center

Alright, first of all we calculate the inner square of the circle. The formula for it is straight forward:

x² + y² = r²    // circle formula
2h² = r²        // all sides of square are of equal length so x == y, lets define h := x
h = r / sqrt(2) // half side length of the inner square


Now, every point between (-h, -h) and (+h, +h) lies within the circle. Here is an image of what I mean:

The remaining blue part is a bit tricky, but not too complicated either. We start at the very top of the blue circle (x = 0, y = -radius). Next, we walk right (x++) until we leave the circle perimiter (until x²+y² < r² doesn't hold anymore). Everything between (0, y) and (x, y) is within the circle. Because of symmetry we can extend this 8 fold by

• (-x, -y), (+x, -y)
• (-x, +y), (+x, +y)
• (-y, -x), (-y, +x)
• (+y, -x), (+y, +x)

now we go down 1 line (y--) and repeat the steps above (while keeping the most recent value of x). Add the center of the circle to each of the points and you're done.

Here is a visualization. There are some artifacts because of the upscaling. The red dot shows what we're testing at each iteration:

Here is the full code (using opencv to draw the stuff):

#include <opencv2/opencv.hpp>

constexpr double sqrt2 = 1.41421356237309504880168;

int main()
{
cv::Point center(200, 200);
constexpr int radius = 180;

// create test image
cv::Mat img(400, 400, CV_8UC3);
cv::circle(img, center, radius, {180, 0, 0}, cv::FILLED);
cv::imshow("img", img);
cv::waitKey();

// calculate inner rectangle
int halfSideLen = radius / sqrt2;
cv::Rect innerRect(center.x - halfSideLen, center.y - halfSideLen, halfSideLen * 2, halfSideLen * 2);
cv::rectangle(img, innerRect, {0, 180, 0}, cv::FILLED);
cv::imshow("img", img);
cv::waitKey();

// probe the rest
int x = 0;
for (int y = radius; y >= halfSideLen; y--)
{
for (; x * x + y * y < radius * radius; x++)
{
// anything between the following points lies within the circle
// each pair of points represents a line
// (-x, -y), (+x, -y)
// (-x, +y), (+x, +y)
// (-y, -x), (-y, +x)
// (+y, -x), (+y, +x)

// center + {(-X..X) x (-Y..Y)} is inside the circle
cv::line(img, cv::Point(center.x - x, center.y - y), cv::Point(center.x + x, center.y - y), {180, 180, 0});
cv::line(img, cv::Point(center.x - x, center.y + y), cv::Point(center.x + x, center.y + y), {180, 180, 0});
cv::line(img, cv::Point(center.x - y, center.y - x), cv::Point(center.x - y, center.y + x), {180, 180, 0});
cv::line(img, cv::Point(center.x + y, center.y - x), cv::Point(center.x + y, center.y + x), {180, 180, 0});

cv::imshow("img", img);
cv::waitKey(20);
}
}

cv::waitKey();
return 0;
}


for (line = 1; line <= r; line++) {
dx = (int) sqrt(r * r - line * line);
for (ix = 1; ix <= dx; ix++) {
putpixel(x - ix, y + line)
putpixel(x + ix, y + line)
putpixel(x - ix, y - line)
putpixel(x + ix, y - line)
}
}


To avoid repeated generation of pixels at axes, it is worth to start loops from 1 and draw central lines (ix==0 or line==0) in separate loop.

Note that there is also pure integer Bresenham algorithm to generate circumference points.

Alright here are the benchmarks I promised.

## Setup

I used google benchmark and the task was to insert all points within the perimiter of the circle into a std::vector<point>. I benchmark for a set of radii and a constant center:

radii = {10, 20, 50, 100, 200, 500, 1000}
center = {100, 500}

• language: C++17
• compiler: msvc 19.24.28316 x64
• platform: windows 10
• optimization: O2 (full optimization)
• threading: single threaded execution

The results of each algorithm is tested for correctness (compared against the output of OPs algorithm).

So far the following algorithms are benchmarked:

1. OP's algorithm enclosing_square.
2. My algorithm containing_square.
3. creativecreatorormaybenot's algorithm edge_walking.
4. Mandy007's algorithm binary_search.

## Results

Run on (12 X 3400 MHz CPU s)
CPU Caches:
L1 Data 32K (x6)
L1 Instruction 32K (x6)
L2 Unified 262K (x6)
L3 Unified 15728K (x1)
-----------------------------------------------------------------------------
Benchmark                                   Time             CPU   Iterations
-----------------------------------------------------------------------------
binary_search/10/manual_time              804 ns         3692 ns       888722
binary_search/20/manual_time             2794 ns        16665 ns       229705
binary_search/50/manual_time            16562 ns       105676 ns        42583
binary_search/100/manual_time           66130 ns       478029 ns        10525
binary_search/200/manual_time          389964 ns      2261971 ns         1796
binary_search/500/manual_time         2286526 ns     15573432 ns          303
binary_search/1000/manual_time        9141874 ns     68384740 ns           77
edge_walking/10/manual_time               703 ns         5492 ns       998536
edge_walking/20/manual_time              2571 ns        49807 ns       263515
edge_walking/50/manual_time             15533 ns       408855 ns        45019
edge_walking/100/manual_time            64500 ns      1794889 ns        10899
edge_walking/200/manual_time           389960 ns      7970151 ns         1784
edge_walking/500/manual_time          2286964 ns     55194805 ns          308
edge_walking/1000/manual_time         9009054 ns    234575321 ns           78
containing_square/10/manual_time          629 ns         4942 ns      1109820
containing_square/20/manual_time         2485 ns        40827 ns       282058
containing_square/50/manual_time        15089 ns       361010 ns        46311
containing_square/100/manual_time       62825 ns      1565343 ns        10990
containing_square/200/manual_time      381614 ns      6788676 ns         1839
containing_square/500/manual_time     2276318 ns     45973558 ns          312
containing_square/1000/manual_time    8886649 ns    196004747 ns           79
enclosing_square/10/manual_time          1056 ns         4045 ns       660499
enclosing_square/20/manual_time          3389 ns        17307 ns       206739
enclosing_square/50/manual_time         18861 ns       106184 ns        37082
enclosing_square/100/manual_time        76254 ns       483317 ns         9246
enclosing_square/200/manual_time       421856 ns      2295571 ns         1654
enclosing_square/500/manual_time      2474404 ns     15625000 ns          284
enclosing_square/1000/manual_time     9728718 ns     68576389 ns           72


## Code

The complete test code is below, you can copy & paste it and test it yourself. fill_circle.cpp contains the implementation of the different algorithms.

### main.cpp

#include <string>
#include <unordered_map>
#include <chrono>

#include <benchmark/benchmark.h>

#include "fill_circle.hpp"

using namespace std::string_literals;

std::unordered_map<const char*, circle_fill_func> bench_tests =
{
{"enclosing_square", enclosing_square},
{"containing_square", containing_square},
{"edge_walking", edge_walking},
{"binary_search", binary_search},
};

std::vector<int> bench_radii = {10, 20, 50, 100, 200, 500, 1000};

void postprocess(std::vector<point>& points)
{
std::sort(points.begin(), points.end());
//points.erase(std::unique(points.begin(), points.end()), points.end());
}

std::vector<point> prepare(int radius)
{
std::vector<point> vec;
vec.reserve(10ull * radius * radius);
return vec;
}

void bm_run(benchmark::State& state, circle_fill_func target, int radius)
{
using namespace std::chrono;
constexpr point center = {100, 500};

auto expected_points = prepare(radius);
enclosing_square(center, radius, expected_points);
postprocess(expected_points);

for (auto _ : state)
{
auto points = prepare(radius);

auto start = high_resolution_clock::now();
target(center, radius, points);
auto stop = high_resolution_clock::now();

postprocess(points);
if (expected_points != points)
{
auto text = "Computation result incorrect. Expected size: " + std::to_string(expected_points.size()) + ". Actual size: " + std::to_string(points.size()) + ".";
state.SkipWithError(text.c_str());
break;
}

state.SetIterationTime(duration<double>(stop - start).count());
}
}

int main(int argc, char** argv)
{
for (auto [name, target] : bench_tests)
for (int radius : bench_radii)
benchmark::RegisterBenchmark(name, bm_run, target, radius)->Arg(radius)->UseManualTime();

benchmark::Initialize(&argc, argv);
if (benchmark::ReportUnrecognizedArguments(argc, argv))
return 1;
benchmark::RunSpecifiedBenchmarks();
}


### fill_circle.hpp

#pragma once

#include <vector>

struct point
{
int x = 0;
int y = 0;
};

constexpr bool operator<(point const& lhs, point const& rhs) noexcept
{
return lhs.x != rhs.x
? lhs.x < rhs.x
: lhs.y < rhs.y;
}

constexpr bool operator==(point const& lhs, point const& rhs) noexcept
{
return lhs.x == rhs.x && lhs.y == rhs.y;
}

using circle_fill_func = void(*)(point const& center, int radius, std::vector<point>& points);

void enclosing_square(point const& center, int radius, std::vector<point>& points);
void containing_square(point const& center, int radius, std::vector<point>& points);
void edge_walking(point const& center, int radius, std::vector<point>& points);
void binary_search(point const& center, int radius, std::vector<point>& points);


### fill_circle.cpp

#include "fill_circle.hpp"

constexpr double sqrt2 = 1.41421356237309504880168;
constexpr double pi = 3.141592653589793238462643;

void enclosing_square(point const& center, int radius, std::vector<point>& points)
{
int sqr_rad = radius * radius;

for (int px = center.x - radius; px <= center.x + radius; px++)
{
for (int py = center.y - radius; py <= center.y + radius; py++)
{
int dx = center.x - px, dy = center.y - py;
if (dx * dx + dy * dy <= sqr_rad)
points.push_back({px, py});
}
}
}

void containing_square(point const& center, int radius, std::vector<point>& points)
{
int sqr_rad = radius * radius;
int half_side_len = radius / sqrt2;
int sq_x_end = center.x + half_side_len;
int sq_y_end = center.y + half_side_len;

// handle inner square
for (int x = center.x - half_side_len; x <= sq_x_end; x++)
for (int y = center.y - half_side_len; y <= sq_y_end; y++)
points.push_back({x, y});

// probe the rest
int x = 0;
for (int y = radius; y > half_side_len; y--)
{
int x_line1 = center.x - y;
int x_line2 = center.x + y;
int y_line1 = center.y - y;
int y_line2 = center.y + y;

while (x * x + y * y <= sqr_rad)
x++;

for (int i = 1 - x; i < x; i++)
{
points.push_back({x_line1, center.y + i});
points.push_back({x_line2, center.y + i});
points.push_back({center.x + i, y_line1});
points.push_back({center.x + i, y_line2});
}
}
}

void edge_walking(point const& center, int radius, std::vector<point>& points)
{
int sqr_rad = radius * radius;
int mdx = radius;

for (int dy = 0; dy <= radius; dy++)
{
for (int dx = mdx; dx >= 0; dx--)
{
if (dx * dx + dy * dy > sqr_rad)
continue;

for (int px = center.x - dx; px <= center.x + dx; px++)
{
for (int py = center.y - dy; py <= center.y + dy; py += 2 * dy)
{
points.push_back({px, py});
if (dy == 0)
break;
}
}

mdx = dx;
break;
}
}
}

void binary_search(point const& center, int radius, std::vector<point>& points)
{
constexpr auto search = []( const int &radius, const int &squad_radius, int dx, const int &y)
{
int l = y, r = y + radius, distance;

while (l < r)
{
int m = l + (r - l) / 2;
distance = dx * dx + (y - m) * (y - m);
if (distance > squad_radius)
r = m - 1;
else if (distance < squad_radius)
l = m + 1;
else
r = m;
}

if (dx * dx + (y - l) * (y - l) > squad_radius)
--l;

return l;
};

int squad_radius = radius * radius;
for (int px = center.x - radius; px <= center.x + radius; ++px)
{
int upper_limit = search(radius, squad_radius, px - center.x, center.y);
for (int py = 2*center.y - upper_limit; py <= upper_limit; ++py)
{
points.push_back({px, py});
}
}
}


This is an optimization that reduce 1/4 the dimension of search:

for (int px = x; px <= x + r; ++px) {
bool find = false;
int dx = x - px, dy;
for (int py = y; !find && py <= y + r; ++py) {
dy = y - py;
if (dx * dx + dy * dy <= r * r)) {
/* (px, py), (px, y+y-py+r), (x+x-px+r, py)
& (x+x-px+r, y+y-py+r) are part of the circle.*/
}else{
find = true; //Avoid increasing on the axis y
}
}
}


or better, improving performance the iteration of second circle for avoiding the if conditional

for (int px = x; px <= x + r; ++px) {
int dx = x - px, py = y;
for (; dx * dx + (py-y) * (py-y) <= r * r; ++py) {
/* (px, py), (px, y+y-py+r), (x+x-px+r, py)
& (x+x-px+r, y+y-py+r) are part of the circle.*/
}
}


well i think that other option is a binary search for upper limit:

int binarySearch(int R, int dx, int y){
int l=y, r=y+R;
while (l < r) {
int m = l + (r - l) / 2;
if(dx*dx + (y - m)*(y - m) > R*R) r = m - 1;
else if(dx*dx + (y - m)*(y - m) < R*R) l = m + 1;
else r = m;
}
if(dx*dx + (y - l)*(y - l) > R*R) --l;
return l;
}

for (int px = x; px <= x + r; ++px) {
int upperLimit = binarySearch(r, px-x, y);
for (int py = y; py <= upperLimit; ++py) {
/* (px, py), (px, y+y-py+r), (x+x-px+r, py)
& (x+x-px+r, y+y-py+r) are part of the circle.*/
}
}


The idea of binary search is to find the upper limit optimally, avoiding the if condition and calculations within the for cycle. For this, it is checked which is the largest integer that makes the distance between the current point and the radius within the circle.

PD: Sorry my English.