bresenham

I have searched throughout the Internet and found hundreds of implementation of Bresenham's line drawing algorithm. But, one thing I found strange is, only two or three of them can cover all of the eight octets. still, they are being used in many applications. For example, this lady implemented this version (line 415) of Bresenham's algorithm. But, it doesn't cover the whole 360 degrees. This guy here seems to be developing a library. But still it doesn't work properly. Can you tell me why? This guy's implementation works fine. But, I suppose it is not Bresenham's Algorithm. It has a very few

I am using the midpoint circle algorithm, also known as Bresenham's, to draw concentric circles. The difference between each circle's radius and that of the next is always 1, so the final result should be a full circular area. However, some pixels are left empty, as shown in the attached image. I'm using Javascript to paint on an HTML5 canvas, manipulating the canvas.getContext("2d").getImageData(...).data array. The circles are alternatively white and red, and the empty pixels are black. You might have to zoom in in order to see what I mean properly. I'm trying to add some code to the

I am using the mid-point circle algorithm (bresenham circle) to efficiently draw whole circles. Is there something similar to draw circle arcs? I would like to specify a start angle and end angle and have only that portion of the circle drawn. Thanks in advance! EDIT: I would like to draw filled circle arcs too, i.e pie-slices. :) Doesn't your platform already have some library that handles drawing these kinds of shapes? Drawing a filled pie-slice: First, cut the pie vertically and horizontally, into quarters. If your pie slice is exactly one of those quarters, or fits entirely inside one of

My computer graphics homework is to implement OpenGL algorithms using only the ability to draw points. So obviously I need to get drawLine() to work before I can draw anything else. drawLine() has to be done using integers only. No floating point. This is what I was taught. Basically, lines can be broken up into 4 different categories, positive steep, positive shallow, negative steep and negative shallow. This is the picture I am supposed to draw: and this is the picture my program is drawing: The colors are done for us. We are given vertices and we need to use Bresenham's Line algorithm to

Based on Wikipedia's article on Bresenham's line algorithm I've implemented the simplified version described there, my Java implementation looks like this: int dx = Math.abs(x2 - x1); int dy = Math.abs(y2 - y1); int sx = (x1 < x2) ? 1 : -1; int sy = (y1 < y2) ? 1 : -1; int err = dx - dy; while (true) { framebuffer.setPixel(x1, y1, Vec3.one); if (x1 == x2 && y1 == y2) { break; } int e2 = 2 * err; if (e2 > -dy) { err = err - dy; x1 = x1 + sx; } if (e2 < dx) { err = err + dx; y1 = y1 + sy; } } Now I do understand that err controls the ratio between steps on the x-axis compared to steps on the y

I have a line-of-sight problem I need to solve by visiting all possible cells in a 3D voxel space between two (non-grid-aligned) points. I have considered using a 3D Bresenham algorithm, but it will skip out some cells. A naive implementation might be to just check points along the line at a higher resolution than the voxel grid, but I was hoping for a more intelligent solution. Anyone got any leads? Came up with this, or see: http://jsfiddle.net/wivlaro/mkaWf/6/ function visitAll(gx0, gy0, gz0, gx1, gy1, gz1, visitor) { var gx0idx = Math.floor(gx0); var gy0idx = Math.floor(gy0); var gz0idx =

I'm trying to rasterize and fill a hypersphere. In essence, I have a d-dimensional grid of fixed size and a sphere (center, radius) and want to find out which cells of the grid overlap with the sphere and store their coordinates. I am aware of the Midpoint circle algorithm which takes advantage of 8-way mirroring and produces the outer cells (border) of a circle. I have also altered the linked wikipedia code so as to fill the circle (that is, to produce the coordinates of all cells inside the border). However I am unaware of any algorithms for higher dimension. For example in 4d, I've been