วีดีโอ

The intermediate conclusion that 2x+1 predicts the next increment, is synonymous with what calculus shows as the slope of the curve x*2 + 2x + c. It's just the slope or derivative of the quadratic at a given value of x, which is not only helpful to realize, but definitely computationally leaner than just calculating points brute-force. Nice tutorial!

One minor flaw - 45 degree lines will be about 30 percent thinner than horizontal or vertical lines, since the algorithm basically "shears" a square rather than rotating and stretching it.

Nice style of explanation!

The slight difference you've noticed when truncating 0.25 appears because of using > instead of >=. For INTEGER values A and B, the inequality A + 0.25 > B is equivalent to A >= B. So in the code you need to replace the check "p > 0" with "p >= 0".

This video would’ve saved me in university, keep it up 🫡

Super! What software are you using for creating these wonderful animations?

Why flipping coordinate system against mathematical standards? Want to sound important?

0:43 I can think of simple ways of mirroring a quarter circle into a whole circle. doing it with 16ths would seem to be as hard as the original problem. or am I missing somthing

I'm disappointed for two reasons. First off, it's nicely animated, no worries there. The problem is the algorithm is simple. I was interested because it had a fancy name, but it turns out to be something I independently invented long ago, and probably many others did so too. Second, you don't seem to apply sRGB correction, i.e. 50%+50% ≠ 100%. In fact it's more like 69%+69% = 100% in sRGB space. That's why in all your animations, the line looks like it has gaps in every place where two half-opaque pixels meet.

"There is zero room for bigotry and racism" well, CNN, you are hosting Mehdi Hassan, so that's a false statement right there.

Thanks. I've seen Bresenham's algorithm before, but this explained it in a way I would be able to reproduce (or rederive) without having to memorize the algorithm. An additional note you may find humorous: You are referring to _y_ subscript 0 as "y naught", but the way you pronounce _naught_ sounded to me as if you had said, "Let's change _why_ to _why not."_ (People make fun of New Yorkers for the way we say _cawfee,_ but our _naught_ doesn't sound like our _not.)_

I did it the same way a long time ago, but instead of calculations I used the fact that the squares of consecutive natural numbers differ by consecutive odd numbers (which also comes out at 11:20), so all I had to do was add and subtract

I'm not into this stuff of optimizing but my idea is to calculate only every second step and filling the gap with DrawLine. Does it work?

Your ability to explain is amazing. Thank you for this video and for the time you have dedicated to us.

I subscribed to your channel in a split second, very good, keep it up!

The opacity is messed up. Lines look terrible, not "perfectly antialiased". Even if the opacity is corrected, vertical/horizontal distance is just an approximation due to triangular inequality. No DDA? Floats? Python?? C'mon! The video had a lot of potential for the way it is presented.

You showed the partially finished result but not the end result. Show how it looks completed.

An excellent explanation, really expressed how the algorithm works Top video.

Initially, This is the worst kind of explanation you can make: figure the problem out, and them put solutions that are at the end to the beginning, to make you look smart, offering no process why it was done that way; seen this on teachers that lack pedagogical skills. You should have continue with your previous example, more to the point: with the original example; then, observe the potential improvements & implement them. You don't explain why those variables are there, you just describe the code, you explain Nothing. The rest of the explanation makes not much sense, you don't explain yNext and many other things' origins, your introverted explanation doesn't make sense, only for you; you should redo this video

I wonder if theres a version of this that is tweaked for the edge of triangles

I think one can get a better result by assuming the line is actually a skinny rectangle, and calculate the percentage of the pixel covered.

Awesome explanation! One question: Is it a mistake at 11:58 that the - 2 * dx * y turns into a + 2 * dx * y and then back again in the following re-arrangement? Or what am I missing?

This is an a great idea for can use the pixels Matrix with flotas values so assume that make an a sub Matrix that pixels for each pixel. This is an a great way to gain resolución on the radials corners of the circles 😊😊😊 Goog explanation of this kind of renderization tricks!!

Antialiased explanation 😉 Nice and clean job at every angle. Excellent job.

Final optimization that should be layered on all these algorithms: memoization.

This was overly complex for such a simple thing..

Excellent, I wish I had this 55 years ago...

I'm struggling with the end point of the line. if the end point is 0.1, 0.2, 0.3 or 0.4 above pixel, I get a gap at the end

This video explains the algorithm almost too well. It's hard to follow along. Explaining the goal and approach was most useful.

I would actually love a video on thick lines. :)

I had this problem once I wanted to code generating a circle in minecraft. Thanks for the video!!

nick wu!!

that was great. thank you!

Note: it's possible to combine Bresenham's integer only multiply-free slope update computation with anti-aliasing à la Wu if you do basically do 2 parallel Bresenham iterations per step of the main loop, but while one is for the position of the pixel to draw & controlling the loop exit, the other one runs independently of the former one in the loop & is responsible for the opacity. Both of these Bresenham parts need to be initialized differently though. Note: & these Bresenham algorithms can be further generalized to draw arbitrary polynomial curves (including the AA) if you subdivide the polynomial into screen diagonal bound parts & add root-finding (of these diagonals to the shapes) prior the main loops while in the main loop you further differentiate the polynomial step update by using newton's method of iterative polynomial differences (from Newton's divided differences triangular scheme, except here we aren't dividing the differences because we want integer only solutions so we end up simply using two integers per resulting difference coefficient updating in lock step, which is what Bresenham is all about).

Awesome , Thanks 😍

This was pretty good video, but I felt that there were a few areas that would have benefited from a more in depth explanation. Nonetheless, good, job!

And with elipses?

I love it!!!!

상!

7:25 you can also just check if the slope is greater than 1

It's beautiful!

for some reason that anti aliasing is very annoying sometimes, especially when you’re drawing a thin circle and try to fill it it fills the entire thing

its very cool and easy

I believe the N64 used a similar algorithm

There's actually a lot more convenient way for drawing a circle. Saving the coordinates of the midpoint in an array of 2 dimensions and by using cos(theta) and sin(theta) from mathematics you can draw short lines from pixel to pixel say from {centerpoint[0] + cos(theta), centerpoint[1] + sin(theta)} to {centerpoint[0] + cos(theta+1), centerpoint[1] + sin(theta+1)} theta ranging from 0 to 359 degrees.

I came up with a similar algorithm for drawing pixelated circles by hand. Starting at x=0 and y=-r, increment x and calculate the offset y given the known x offset and radius plugged into the Pythagorean theorem. Once you reach x=r/2, you can mirror the result 7 more times.

Python program for wafer Cp test equipment

Learners* damnit

A very good video for intermediate leaners

Indeed