วีดีโอ

These videos are amazing. Hope you post more soon.

U LEGEND HOW U DO THIS MAN

I'd take stable and sharp Bresenham over the unstable antialiased Wu any day. I just can't stand when a line changes color while moving/rotating. It must remain the same color over the same background regardless of the movement/rotation.

This is just basic highschool geometry applied. I wish I was taught this at school. I mean - not the geometry, but how can it be used to draw things on screens ;) When I look at it now it's so easy and obvious, but back in the days, when I was a kid that was way more intelligent than I am today, but I had no necessary knowledge or experience - such algorithms was just magic. I had the geometry from school, I had some programming knowledge from books but I was not able to figure out how to draw vector graphics properly. I've seen articles on this in magazines, I read about them in books but it was like too hard for the teenage me. Now my brain is much slower, but when I see how the algos work, I'm sure you could easily explain it to a 10 year old.

How the algor. knows it has completed 1/8 of the circle?

This is the first time i wish i could give more likes.

what do you use for the animations?

0:40 if they are symmetrical, why 1/8? Why not 1/16? 1/32?

If I am not mistaken, you can also multiply p by four and you would get rid of the fractions, while still only checking for the sign of p, i.e., 4*p.

I can't imagine how I came across to this beautiful video by learning about AccelStepper library!

13:13 Filled circle has easier algorithm. You can fill every pixel on some distance from point. By using sqrt + pow

can't you just use cosine and sine ?????????

Why not calculate 4*p instead of p ? This will help to get rid of fractional numbers like 0.25 or 1.25 and convert everything into integers, while preserving the sign of p.

it'd be neat if you looked into signed distance fields for fast anti-aliased vector graphics, it's quite versatile. i can give some ressources if you want to look into it (or even discuss about it) !

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!