Previous | Next --- Slide 52 of 64
Back to Lecture Thumbnails

By doing this, time complexity has been decreased to O(n), what further optimization is applied in modern sw/hw?


Since every lit up pixel should be close to one another, is it possible to use algorithms such as depth-first search to find all the pixels that need to be lit up?


I guess modern software/hardware can optimize the process with high parallelism, with parallel algorithm and hardware such as GPU?


Is further optimization in modern software/hardware primarily parallelization, or is there a lot of optimization to reduce total work as well? It seems like it would be difficult or impossible to do better than O(n) work on this problem, since O(n) pixel illuminations are required.


good interactive tutorial


What would be a brief high-level overview of how this is done in modern graphics, and how this gives a good improvement?


How do we represent curves with a similar method? Is it possible?


As the line is represented with two endpoints, what happens if I want to increase the line weight?


If the line passes through the crossing point of two diamonds, will both diamonds be rendered?


Does the assumption of integer coordinates are at pixel centers always hold in real situations?


Instead of incrementing the x-distance, wouldn't it be better to represent the line as a vector and increment in the direction of that vector?


What do people do for non-integer endpoints/slopes?


If the image is dense with many lines, would scanline rendering have an advantage?


What if the endpoints aren't at the pixel centers.. does that change anything?


Is this algorithm how they determine the diamond rule? Or was it a coincidence/for convenience that all the pixels chose matches the diamond rule?


How are lines drawn in modern software/hardware?


How is line rasterization actually preformed in modern hardware and software? Is there a de-factor method that is relatively widespread and accepted, or are there variations that are preferred in different use cases?


How should we prove the diamond rule is satisfied using this algorithm?


Can this sort of "incremental" thinking be applied to animation as well? It seems wasteful to clear every pixel and redraw the entire shape if only part of the shape actually changes between time steps.


If a line is drawn on the border of the diamonds (a line with 45-degree slope), which set of pixels will light up?


Could we connect points using more complex functions instead of straight lines by using a similar technique of incrementing u and changing v accordingly?


Could we apply this algorithm to rasterize a circle? Could we maybe consider different slopes at different points on the curve, and just follow the same algorithm?


I am wondering whether we can add random processes so that we can see this line slightly different each time. Is this probably a little bit comfortable?


What is the modern method for drawing lines?