line drawing - univie.ac.atvda.univie.ac.at/.../graphics/15w/lecturenotes/14_lines.pdf ·...

© Machiraju/Zhang/Möller

Line Drawing

Introduction to Computer GraphicsTorsten Möller / Mike Phillips


Rendering Pipeline

Hardware

Modelling Transform Visibility

Illumination +Shading

ColorPerception,Interaction

Texture/Realism


Reading

• Angel – Chapter 8.8-8.10

3


Today

• Recap - the graphics pipeline • Rasterizing lines

– brute-force – DDA – Bresenham

• Rasterizing quadrics • Anti-aliasing

4


• From the modeling stage to image formation • Pipelined approach helps increase system

throughput – Throughput: rate at which data flows through the

system – In a pipeline, data processing in subsequent blocks can

be done in parallel – Especially effective when the same sequence of

operations are to be performed on large quantity of data – true in graphics

The graphics pipeline

5


Vertex processor• Per-vertex operations (vertices define objects/

primitives) • Two main functionalities:

– Coordinate transformations – Color computation at each vertex (shading models)

• Objects/geometry first defined in their own coordinate systems, then transformed into a world space — modeling transformation

• Then objects are transformed from world space into the camera coordinate system — viewing transformation and projection transformation

6


Clipping and primitive assembly

• Model a finite field of vision • Remove objects outside a

finite clipping volume • Need to be done on a primitive

by primitive basis, not on vertices

• Output is a set of primitives whose projections can appear in the image

7


Rasterizer• The rasterizer converts a primitive into a set of

fragments • A fragment stores per pixel information for its

associated primitive, later used to determine whether the fragment contributes to pixel color and to compute the pixel color

– Raster/pixel location (in the frame buffer) – Depth, e.g., to determine whether this fragment “survives” – Interpolated attributes, e.g., color and texture coordinate,

from the previous stages – Alpha value (for blending) – Window ID, etc.

8


Fragment processing• Performs per-fragment operations • Main function is to compute the color at a pixel,

using information stored in the fragments, e.g., depth, alpha, texture coordinates; can also add in fog and other effects

• A (programmable) fragment shader is a program that performs the processing which replaces the OpenGL fixed functionality, e.g., simply using interpolated attributes

• Similar to a vertex shader (per-vertex operations) • Shader programs typically have limited instruction

set9


Drawing or rasterization of primitives first. Consider lines and polygons.

Where are we at now?


Assumptions• Transformation, clipping, projection already done • Primitives to rasterize are actually on the screen • Work with 2D screen coordinates with square

pixels

11

(0, 0)

(N, M)


Primitives

• Polygons • explicit curves

– lines, quadrics • parametric curves/surfaces

– Curves, Surfaces • implicit description • Misc

– particle systems/points, fractals

12


Explicit Descriptions

• Given - an explicit equation y = f(x)

• cannot get multiple values of y • not rotationally invariant • no infinite slope (vertical line) • axis dependent (y depends on x) • specify one variable and resolve for the

other13


Lines

• Given - an explicit line equation y = mx+n

• Which pixels to set?

14

http://bert.stuy.edu/pbrooks/graphics/demos/BresenhamDemo.htm


Scan Converting Lines

• Compute the coordinates of pixels that lies on or near an ideal, infinitely thin line imposed on a 2D raster grid

• Assumptions – line will be 1 pixel thick and will approximate

an infinitely fine line – pixels represented as disjoint circles, centred

on a grid (unless specified otherwise) – integer coordinates of endpoints – pixel on or off (2 states)

15


Scan Converting Lines (2)

• Desirable properties: – constant brightness (irrespective of length or

orientation) – 1 pixel per column (-1 <= slope <= 1), 1

pixel per row (slope > +/- 1) – as close to the ideal/as straight as possible – allow control of pen, line and endpoint styles – drawn as smoothly as possible

(anti-aliasing) – drawn as rapidly as possible

16


Scan Converting Lines (3)

• Difficulties: – brightness and pixel criteria conflict (for bi-

level displays)

17


Basic – Brute force

• Find slope m = rise/run or y = mx + b • increment x by 1 (xi); • calculate yi = mxi + b • pixel (xi, round(yi)) turned on • simple, but inefficient:

– floating point multiplication – addition – round

18


Incremental - DDA• multiplication can

be eliminated:

• called digital differential analyzer (DDA) - after mechanical device that solves differential equations by numerical methods

• Drawbacks: – floating point values (m,y) – round operation – special cases could be done more quickly

19

yi+1 = mxi+1 + b

= m(xi + 1) + b

= yi +m


Lines - Bresenham

• Special case of Midpoint Line Algorithm • uses only integer arithmetic & no

rounding • idea is to provide the best-fit

approximation to a true line by minimizing the error (distance) to the true line

• slope (rest is done with reflection)

20


• Explicit line equation:

• Implicit line equation:

• Main idea - call on decision variable:

Lines - Bresenham (2)

21

y = mx+ b =�y

�x

x+ b

F (x, y) = x�y � y�x+ h

di = F (xi + 1, yi + 1/2)

= (xi + 1)�y � (yi + 1/2)�x+ h


• if di < 0, pick O, and:

• if di > 0, pick NO, and:

• if di = 0, pick either one, but consistently


22

�O = di+1 � di

= F (xi + 2, yi + 1/2) = �y

�NO = di+1 � di

= F (xi + 2, yi + 3/2) = �y ��x



• Additional issues: – Endpoint order: we want P0 to P1 to look

exactly the same as P1 to P0 – Starting at edge of a clip rectangle: we must

use the midpoint test result rather than computing intersections analytically if we are to ensure the correct sequence of pixels

23



24


Quadrics - Circles

• Circles, ellipsoids, etc.

• divide in 8 quadrants • What is special

about 8-foldsymmetry?

25

y =p

R

2 � x

2


Quadrics - Circles (2)

• Midpoint Circle Algorithm – trace out arc in 2nd octant and draw the rest

by symmetry – choose between E and SE pixel at each

stage

26


Quadrics - Circles (3)

• incremental - now have higher order

• higher order difference system

27

D(x) = (x+�x)2 � x

2 = 2x�x+�x

2

D(x+�x)�D(x) = 2�x

2


Quadrics - Ellipses

• Can a midpoint algorithm be developed for ellipses? What are the important differences from circles?

• The result is Da Silva's algorithm (the idea is illustrated below):

28


Lines - Anti-Aliasing

• A continuous (zero-width) line is “invisible” in a discrete grid.

• Give line thickness - How? • Signal Processing Approach:

– line is high-frequency – want to avoid aliasing – what to do first?

29


Lines - Anti-Aliasing (2)

• Bandlimit signal - how? • Convolve with smoothing filter - which?

30



• Box filter not all that good • convolve it again - why? • Then resample!

31



• Other alternatives? • Can we improve this algorithm?

32


General Anti-Aliasing: super-sampling

• simple by expensive • simply sample n times within a pixel and

average!

33


remember …

34


Aliasing: Sampling a Zone Plate

Zone plate: sin(x2 + y2)

Sampled at 128 x 128 and reconstructed to 512 x 512 using windowed sinc

Left rings: part of the signal Right rings: aliasing due to undersampling

36


Point vs. supersampling

37


is this better?

38

https://www.youtube.com/watch?v=hqi0114mwtY

line drawing - univie.ac.atvda.univie.ac.at/.../graphics/15w/lecturenotes/14_lines.pdf ·...

Documents