Sweep Fill Details

1
Sweep Fill Details

• Maintain a list of active edges in case there are
  multiple spans of pixels - known as Active Edge
  List.
• For each edge on the list, must know x-value,
  maximum y value of edge, m
• Maybe also depth, color
• Keep edges in a table, indexed by minimum y value
  - Edge Table

• For row min to rowmax
• AELappend(AEL, ET(row))
• remove edges whose ymaxrow
• sort AEL by x-value
• fill spans
• update each edge in AEL

2
Edge Table A list per row
6
Row
6
5
5
4
4
4
0
6
3
3
2
2
1
1
2
0
4
6
0
6
1
2
3
4
5
6
6
0
6
ymax
xmin
1/m
3
Active Edge List just before filling each row
6
Row
6
5
5
4
0
6
6
0
6
4
4
4
0
6
6
0
6
3
3
2
0
4
6
0
6
2
2
0
4
6
0
6
2
1
2
0
4
6
0
6
1
1
2
3
4
5
6
6
0
6
ymax
x
1/m
4
Edge Table
Row
6
6
5
5
4
4
3
3
2
2
1
2
1
5
6
-1
5
1
6
0
6
1
2
3
4
5
6
ymax
xmin
1/m
5
Active Edge List just before filling each row
6
Row
6
5
5
4
4
3
-1
5
5
1
5
3
3
4
1
5
4
-1
5
2
2
3
1
5
5
-1
5
1
1
2
1
5
6
-1
5
1
2
3
4
5
6
6
0
6
ymax
x
1/m
6
Comments

• Sort is quite fast, because AEL is usually almost
  in order
• OpenGL limits to convex polygons, meaning two and
  only two elements in AEL at any time, and no
  sorting
• Can generate memory addresses (for pixel writes)
  efficiently
• Does not require floating point - next slide

7
Dodging Floating Point

• For edge, m?x/?y, which is a rational number
• View x as xixn/?y, with xnlt?y. Store xi and xn
• Then x-gtxm is given by
• xnxn?x
• if (xngt?y) xixi1 xnxn- ?y
• Advantages
• no floating point
• can tell if x is an integer or not, and get
  floor(x) and ceiling(x) easily, for the span
  endpoints
• Watt Sect 6.4.1 gives a confusing version

8
Anti-Aliasing

• Recall We cant sample and then accurately
  reconstruct an image that is not band-limited
• Infinite Nyquist frequency
• Attempting to sample sharp edges gives jaggies,
  or stair-step lines
• Solution Band-limit by filtering (pre-filtering)
• What sort of filter will give a band-limited
  result?
• But when doing computer rendering, we dont have
  the original continuous function

9
Pre-Filtered Primitives

• We can simulate filtering by rendering thick
  primitives, with ?, and compositing
• Expensive, and requires the ability to do
  compositing
• Hardware method Keep sub-pixel masks tracking
  coverage

Filter
?1/6
1/6
?2/3
2/3
over
?1/6
?1/6
?2/3
1/6
Ideal
?1/6
Pre-Filtered and composited
10
Post-Filtering (Supersampling)

• Sample at a higher resolution than required for
  display, and filter image down
• Two basic approaches
• Generate extra samples and filter the result
  (traditional super-sampling)
• Generate multiple (say 4) images, each with the
  image plane slightly offset. Then average the
  images
• Requires general perspective transformations
• Can be done in OpenGL using the accumulation
  buffer
• Issues of which samples to take, and how to
  average them

11
Where We Stand

• At this point we know how to
• Convert points from local to window coordinates
• Clip polygons and lines to the view volume
• Determine which pixels are covered by any given
  line or polygon
• Anti-alias
• Next thing
• Determine which polygon is in front

12
Visibility

• Given a set of polygons, which is visible at each
  pixel? (in front, etc.). Also called hidden
  surface removal
• Very large number of different algorithms known.
  Two main classes
• Object precision computations that decompose
  polygons in world to solve
• Image precision computations at the pixel level
• All the spaces in the viewing pipeline maintain
  depth, so we can work in any space
• World, View and Window space are all used

13
Visibility Issues

• Efficiency - why render pixels many times?
• Accuracy - answer should be right, and behave
  well when the viewpoint moves
• Must have technology that handles large, complex
  rendering databases
• In many complex worlds, few things are visible
• How much of the real world can you see at any
  moment?
• Complexity - object precision visibility may
  generate many small pieces of polygon

14
Painters Algorithm (Image Precision)

• Algorithm
• Choose an order for the polygons based on some
  choice (e.g. depth to a point on the polygon)
• Render the polygons in that order, deepest one
  first
• This renders nearer polygons over further
• Difficulty
• works for some important geometries (2.5D - e.g.
  VLSI)
• doesnt work in this form for most geometries -
  need at least better ways of determining ordering

Fails
zs
Which point for choosing ordering?
xs
15
The Z-buffer (1) (Image Precision)(Watt 6.6.1)

• For each pixel on screen, have at least two
  buffers
• Color buffer stores the current color of each
  pixel
• The thing to ultimately display
• Z-Buffer stores at each pixel the depth of the
  nearest thing seen so far
• Also called the depth buffer
• Initialize this buffer to a value corresponding
  to the furthest point (z1.0 for screen and
  window space)
• As a polygon is filled in, compute the depth
  value of each pixel that is to be filled
• if depth lt z-buffer depth, fill in pixel color
  and new depth
• else disregard

16
The Z-buffer (2) (Watt 6.6.9)

• Advantages
• Simple and now ubiquitous in hardware
• A z-buffer is essentially what makes a graphics
  card 3D
• Computing the required depth values is easy
• Disadvantages
• Over-renders - worthless for very large
  collections of polygons
• Depth quantization errors can be annoying
• Cant easily do transparency or filtering for
  anti-aliasing (Requires keeping information about
  partially covered polygons)

17
Z-Buffer and Transparency

• Must render in back to front order
• Otherwise, would have to store first opaque
  polygon behind transparent one

Front
Partially transparent
1st or 2nd
3rd
Opaque
2nd
Opaque
1st
1st or 2nd
Recall this color and depth
18
OpenGL Depth Buffer

• OpenGL defines a depth buffer as its visibility
  algorithm
• The enable depth testing glEnable(GL_DEPTH_TEST)
• To clear the depth buffer glClear(GL_DEPTH_BUFFER
  _BIT)
• To clear color and depth glClear(GL_COLOR_BUFFER_
  BITGL_DEPTH_BUFFER_BIT)
• The number of bits used for the depth values can
  be specified (windowing system dependent, and
  hardware may impose limits based on available
  memory)
• The comparison function can be specified
  glDepthFunc()

19
The A-buffer (Image Precision)(Watt 14.6)

• Handles transparent surfaces and filter
  anti-aliasing
• At each pixel, maintain a pointer to a list of
  polygons sorted by depth, and a sub-pixel
  coverage mask for each polygon
• Matrix of bits saying which parts of the pixel
  are covered
• Algorithm When drawing a pixel
• if polygon is opaque and covers pixel, insert
  into list, removing all polygons farther away
• if polygon is transparent or only partially
  covers pixel, insert into list, but dont remove
  farther polygons

20
The A-buffer (2)

• Algorithm Rendering pass
• At each pixel, traverse buffer using polygon
  colors and coverage masks to composite
• Advantage
• Can do more than Z-buffer
• Coverage mask idea can be used in other
  visibility algorithms
• Disadvantages
• Not in hardware, and slow in software
• Still at heart a z-buffer Over-rendering and
  depth quantization problems

over

21
Scan Line Algorithm (Image Precision)(Watt
6.6.5-6.6.7)

• Assume polygons do not intersect one another
• Except maybe at edges or vertices
• Observation across any given scan line, the
  visible polygon can change only at an edge
• Algorithm
• fill all polygons simultaneously
• at each scan line, have all edges that cross scan
  line in AEL
• keep record of current depth at current pixel -
  use to decide which is in front in filling span

22
Scan Line Algorithm (2)
zs
zs
xs
xs
Spans
zs
Where polygons overlap, draw front polygon
xs
23
Scan Line Algorithm (3)

• Advantages
• Simple
• Potentially fewer quantization errors (more bits
  available for depth)
• Dont over-render (each pixel only drawn once)
• Filter anti-aliasing can be made to work (have
  information about all polygons at each pixel)
• Disadvantages
• Invisible polygons clog AEL, ET
• Non-intersection criteria may be hard to meet