Neighbors of a point on a circle using Bresenham's algorithm

// C++ program to find neighbors of a given point on circle
#include <bits/stdc++.h>
using namespace std;

// map to store all the pixels of circle
map<int, list<int> > mymap;
map<int, list<int> >::iterator it;

// This program will print all the stored pixels.
void showallpoints(map<int, list<int> >& mymap)
{
    // To print out all the stored pixels,
    // we will traverse the map using iterator
    for (it = mymap.begin(); it != mymap.end(); it++) {

        // List contains all the y-coordinate.
        list<int> temp = it->second;

        for (auto p = temp.begin(); p != temp.end(); p++) {
            cout << "(" << it->first << ", " << *p << ")\n";
        }
    }
}

// This function will stored the pixels.
void putpixelone(int m, int n, map<int, list<int> >& mymap)
{
    // check if the given pixel is present already in the
    // map then discard that pixel and return the function.
    map<int, list<int> >::iterator it;

    // if x-coordinate of the pixel is present in the map then
    // it will give iterator pointing to list of those pixels 
    // which are having same x-coordinate as the input pixel
    if (mymap.find(m) != mymap.end()) {

        it = mymap.find(m);
        list<int> temp = it->second;
        list<int>::iterator p;

        // Checking for y coordinate
        for (p = temp.begin(); p != temp.end(); p++) 
            if (*p == n)
                return;

        // if map doesn't contain pixels having same y-
        // coordinate then pixel are different and store
        // the pixel
        mymap[m].push_back(n);
    } else

        // Neither x nor y coordinate are same.
        // put the pixel into the map
        mymap[m].push_back(n);

    return;
}

// generate all the pixels using 8 way-symmetry of circle
void putpixelall(int p, int q, int x1, int y1)
{
    putpixelone(p + x1, q + y1, mymap);
    putpixelone(q + x1, p + y1, mymap);
    putpixelone(q + x1, -p + y1, mymap);
    putpixelone(p + x1, -q + y1, mymap);
    putpixelone(-p + x1, -q + y1, mymap);
    putpixelone(-q + x1, -p + y1, mymap);
    putpixelone(-q + x1, p + y1, mymap);
    putpixelone(-p + x1, q + y1, mymap);
    return;
}

// Brensenham's circle algorithm
void circle(int centerx, int centery, int r)
{
    // initial coordinate will be (0, radius) and we 
    // will move counter-clockwise from this coordinate
    int x = 0;
    int y = r;

    // decision parameter for initial coordinate
    float decision_para = 3 - 2 * (r);
    putpixelall(x, y, centerx, centery);

    while (x < y) {

        // x will always increase by 1 unit
        x = x + 1;
        if (decision_para <= 0) {

            // if decision parameter is negative then N 
            // will be next pixel N(x+1, y)
            decision_para = decision_para + 4 * x + 6;
        } else {

            // if decision parameter is positive then N 
            // will be next pixel S(x+1, y-1)
            y = y - 1;
            decision_para = decision_para + 4 * (x - y) + 10;
        }

        // Function call to generate all the pixels by symmetry
        putpixelall(x, y, centerx, centery);
    }
    return;
}
// this program will find the neighbors of a given point`
void neighbours(map<int, list<int> >& mymap, int given_pointx, 
                                             int given_pointy)
{
    for (it = mymap.begin(); it != mymap.end(); ++it) {
        if (it->first == given_pointx + 1 || 
            it->first == given_pointx - 1) {
            list<int> temp1 = it->second;
            list<int>::iterator itr1;
            for (itr1 = temp1.begin(); itr1 != temp1.end(); ++itr1) {

                // Checking for same-sign.
                if (given_pointy >= 0 && *itr1 >= 0)
                    cout << "(" << it->first << ", " << *itr1 << ")\n";
                else if (given_pointy <= 0 && *itr1 <= 0)
                    cout << "(" << it->first << ", " << *itr1 << ")\n";
                else
                    continue;
            }
        }
    }
}

// Driver code
int main()
{
    int center_x = 0, center_y = 0;
    float r = 3.0;
    circle(center_x, center_y, r);
    showallpoints(mymap);
    int nx = 3, ny = 0;
    neighbours(mymap, nx, ny);
    cout << endl;
    return 0;
}