private static final void drawCircleFootprint(Graphics graphics, int xc,
            int yc, int thickness) {

        // Declares and intialise helper variables
        final List<Integer[]> edges1stOctant, edges2ndOctant, edgesQuadrant;
        edgesQuadrant = new ArrayList<>();
        edges2ndOctant = new ArrayList<>();

        // Extract the radius from the thickness
        final int radius = thickness / 2;

        // Capture or record all points along the 1st octant.
        edges1stOctant = drawCircle(graphics, xc, yc, radius);

        // Add the first half of the points along the quadrant where 1st 
        //      octant lies.
        edgesQuadrant.addAll(edges1stOctant);

        // Temperorary helper for reversing the element position of 
        //      edges1stOctant to this helper variable.
        // Reverse because the 2nd octant is simply a reverse of the 1st octant.
        List<Integer[]> listHelper = new ArrayList<>();

        // Reverse the order of the 1st octant on the newly copied helper var
        for (int i = edges1stOctant.size() - 1; i > -1; i--) {
            listHelper.add(edges1stOctant.get(i));
        }

        // Temporary holder for swapping x and y in the second octant
        Integer[] helper;

        // Extract all coordinates for 2nd octant with the use of listHelper
        //      helper variables. 
        // In the second octant, the x and y of the 1st octant are reverse.
        // 2nd octant lies adjacent next to positive x at y = 0;
        // 1st octant lies adjacent next to positive y at x = 0;
        for (Integer[] aPoint : listHelper) {
            helper = new Integer[2];
            helper[0] = aPoint[1];
            helper[1] = aPoint[0];

            edges2ndOctant.add(helper);
        }

        // Add the remaining coordinates to the edgesQuadrant list
        edgesQuadrant.addAll(edges2ndOctant);

        // REMOVES DOUBLE EXTRA X COORDINATES on the same Y COORDINATE
        // Since some of the edges points (x coordinate) are more than one
        //      (due to Bresenham algorithm) in the same y coordinate 
        //      (helps eliminate filling the same x horizontal plane 
        //      when iterating the edges later for filing
        //      gaps), these points are redundant so it must not be use as
        //      reference later when filling the circle footprint.
        List<Integer[]> newEdgeQuadrant = new ArrayList<>();
        int yOld = -1, yNew; // Initialize for comparing 1st element with this.
        // there's no -1 y coordinate so it safe to use this as initial value.

        for (Integer[] aPoint : edgesQuadrant) {
            yNew = aPoint[1];
            if (yNew != yOld) {
                newEdgeQuadrant.add(aPoint);
                yOld = yNew;
            }
        }

        // FILLING THE CIRCLE by QUADRANT SYMMETRY //
        int xmin, xmax, ymin, ymax;

        xmin = 0;
        xmax = radius;
        ymin = 0;
        ymax = radius;

        // It starts at point xmin and ymax (0,r) all the way to point xmin and ymin (0,0)
        for (int y = ymax; y >= ymin; y--) {
            for (Integer[] aPoint : newEdgeQuadrant) {
                if (aPoint[1] == y) {
                    // Fills the circle horizantally from xmin to xmax
                    for (int x = xmin; x < aPoint[0]; x++) {
                        fillCircleQuadrant(graphics, x, y, xc, yc);
                    }
                    break;
                }
            }
        }

        // Fills the middle horizontal x line gap from xmin to xmax and
        //      from xmin to negative xmax;
        for (int x = xmin, y = 0; x <= radius; x++) {
            graphics.drawLine(x + xc, y + yc, x + xc, y + yc);
            graphics.drawLine(-x + xc, y + yc, -x + xc, y + yc);
        }

    }