computer graphics - week 6

Computer Graphics - Week 6Computer Graphics - Week 6

Bengt-Olaf SchneiderBengt-Olaf SchneiderIBM T.J. Watson Research CenterIBM T.J. Watson Research Center

© Bengt-Olaf Schneider, 1999Computer Graphics – Week 6

Questions about Last Week ?Questions about Last Week ?


Questions about Assignment ?Questions about Assignment ?

Comments about submission

Deadline is Friday, 2/26 at 5:30 pmStandard rules about penalties etc. apply

Impress us with clean code: Comments, no dead code, ...

Put a header with your name in every file you submit

Look for mechanics of submission on the webpage


Overview of Week 6Overview of Week 6

Scan Conversionlines, triangles, polygonsattribute interpolation and perspective correction

Second Assignment


Scan Conversion: OverviewScan Conversion: Overview

Scan Conversion of an object a.k.a RasterizationDetermine which pixels are affected by the object, i.e. which pixels must be set to display the objectDetermine pixel value at those pixelsPixel values a.k.a. pixel attributes

Color (RGB), Depth (Z), Alpha (A), e.g. transparency, Texture (u,v), Fog, Stencil, etc.Color (RGB), Depth (Z), Alpha (A), e.g. transparency, Texture (u,v), Fog, Stencil, etc.

A


Scan Conversion: PrimitivesScan Conversion: Primitives

Each primitive type requires a special scan conversion procedure

For instance, polygons are rasterized different from circle or lines

We will discussPointsLinesTrianglesPolygons

We will not discuss (see textbook)Circles and ellipsesFreeform surfacesText


Scan Conversion in the Rendering Scan Conversion in the Rendering PipelinePipeline

ClippingLightingCalculations

ModelingTransforms

ViewingTransforms

Geometric Operations

Image Generation

SetupCalculations

ScreenRefresh

FrameBufferRasterization Pixel

Processing

Perspective+ Viewport

Scan conversion follows the geometric operationsConverts geometric primitives to screen primitives (pixels)Scan conversion falls into 2 parts: setup calculations + rasterization


Scan Conversion: StepsScan Conversion: Steps

SetupScan conversion is typically performed as an iterationSetup calculates the parameters of the iteration, e.g. increments

Determine covered pixelsCalculate the pixel coordinates of pixels belonging to the objectThis is done either by testing candidate pixels or by enumerating covered pixels

Determine pixel valueGiven a pixel belonging to an object, calculate and assign the value of the pixel attributes

We will discuss these steps for each primitive type


What is a Pixel ? (1)What is a Pixel ? (1)

Pixel means "Picture Element"A pixel is the smalles addressable unit on the screen

On a CRT the beam can be modulated at the granularity of a pixel

The actual shape of a pixel depends on the deviceCRT: Pixels are approximately roundLCD: Pixels are square



Pixels are organized as rows and columnsScreen coordinates describe pixel location

We will use a right-handed screen coordinate system

Pixel addresses are integer values, denoting the location of the pixel center

A pixel covers a 1x1 areaPixel corners lie on [x +/- 0.5, y +/- 0.5]

Y

X

0 1 2 3

0

1

2



There are other ways to define a pixelFor instance: lower-left corner is on integer coordinatesThen, pixel centers lie on half-integer coordinates

Also, pixel coordinates may be defined differentlyLeft-handed coordinate systems


Scan Conversion of PointsScan Conversion of Points

Points are described as a single coordinate in screen coordinatesSet the pixel whose pixel center is closest to the point

Round the points coordinates to the next pixel coordinates

Points have one a single value for each attribute

Constant color, depth etc. for each point


Scan Conversion of Lines (1)Scan Conversion of Lines (1)

Rasterization of a line computes pixels on or near the ideal, infinitely thin, straight line

Most pixels lie off the lineRaster lines are not straightLines are not infinitely thin

RequirementsCentered around ideal lineFor thin lines, one pixel thickFor slopes of -1 to +1, set exactly one pixel per columnMonotonous behavior



Requirement: Only one pixel per column (row)

X-major linesSlope between -1.0 and +1.0Advances faster in X than Y

Y-major lineSlope between +1.0 (through infinity) and -1.0Advances faster in Y than X

X

Y

X major

Y major



Simple Approach:Determine whether line is of X or Y major formFor each X coordinate along the line compute the Y coordinate

∆ ∆

∆ ∆

∆ ∆

∆ ∆

x x x y y y

x y

m y xx x x x x

y y m x xx y

m x yy y y

x x m y yx y

E S E S

S E

S S

S E

S S

= − = −

≥

== ≤ + +

= + −

== ≤ + +

= + −

;

( / / X - major

; for ; ; ) ; setpixel round round

/ /Y - major ; for ; y ; y ) ; setpixel round round

Ifthen

else

)

( )(

( ( ), ( )) ;

( )(

( ( ), ( )) ;



Simple Approach requires ...floating point calculationsone multiplication per pixel (∆y/∆x or ∆x/∆y can be precomputed !)one float-to-int conversion

This is expensive and slow !

We would like to produce the same result and ...avoid multiplications by using iterative additions,use only integer calculations (Bresenham algorithm)



Digital Differential Analyzer (DDA)

Incremental computation of pixel coordinatesRelies on yx+1 = m(x+1)+b = mx+b + m = yx + m1 floating point addition and 2 float-to-int conversions per pixel

Next we will eliminate the floating point computations

∆ ∆

∆ ∆

∆ ∆

∆ ∆

x x x y y y

x y

m y xx x y y x x x

y y mx y

m x yx x y y y

x x mx y

E S E S

S S E

S S E

= − = −

≥

== = ≤ + +

= +

== = ≤ + +

= +

;

( / / X - major

; for , ; ; ; setpixel round round

/ /Y - major ; for , ; y ; y ; setpixel round round

Ifthen

else

)

( )

( ( ), ( )) ;

( )

( ( ), ( )) ;



Midpoint Algorithm (Bresenham algorithm)Basic idea: Incrementally compute an error term dChose next pixel H if the line is above M and otherwise pixel LWorks only for lines with slopes of 0 ... +1 (first octant)

xi xi+1

yi

yi+1

MP d

H

L



Line can be represented in two forms:

Comparing coefficients:Using m = ∆y / ∆x

Distance of a point from the line:F = 0 for points on the lineF > 0 for points below the lineF < 0 for points above the line

ll:: (Implicit form) y = (Slope - intercept form)

ax by cmx B

+ + =+

0

a y b x c B x= = − = ⋅∆ ∆ ∆ ; ;

F x y ax by cy x x x B x

( , ) = + += ⋅ − ⋅ + ⋅∆ ∆ ∆


Midpoint criterion:Determine position of M with respect to the line

Compute sign of error dDetermine pixel

If d<0 choose HIf d<0 choose HIf d>0 choose LIf d>0 choose L

Next, compute the value of d for the next pixel xi+2


d F M F x yF x y

a x b y c

i M M

P P

P P

+ = == + += ⋅ + + ⋅ + +

1

1 1 2

1 1 2

( ) ( , )( , )

b g b g

xi xi+1

yi

yi+1

MP d

H

L


Next, compute the value of d for the next pixel xi+2

This depends on which pixel (L or H) was chosenIf L was chosen ....................

If H was chosen ....................


d F M F x yF x y

a x b y c

i M M

P P

P P

+ = == + += ⋅ + + ⋅ + +

1

1 1 2

1 1 2

( ) ( , )( , )

b g b gd F x y

a x b y c

a x b y c a

d a

i P P

P P

P P

i

+

+

= + += ⋅ + + ⋅ + += ⋅ + + ⋅ + + += +

2

1

2 1 2

2 1 2

1 1 2

( , )

b g b gb g b g

d F x y

a x b y c

a x b y c a b

d a b

i P P

P P

P P

i

+

+

= + += ⋅ + + ⋅ + += ⋅ + + ⋅ + + + += + +

2

1

2 3 2

2 3 2

1 1 2

( , )

b g b gb g b g


The new d is computed incrementally as:

How is d initialized ?(xS,yS) is on the lineTherefore: F(xS,yS) = 0.

In practice we only care about the sign of dTherefore, we use d'=2d to avoid the division by 2


dd a y y

d a b y yii i L

i i H+

+ +

+ +=

+ =+ + =

RST21 2

1 2

if if

d F x y

a x b y c

a x b y c a b

F x y a b

a b

S S

S S

S S

S S

1 1 1 2

1 1 2

2

2

2

= + += ⋅ + + ⋅ + += ⋅ + ⋅ + + += + += +

, /

/

/

, /

/

b gb g b g

b gb g


Initialization:

dx = x_end - x_start ;dy = y_end - y_start ;d = 2*dy - dx ;incr_L = 2*dy ;incr_H = 2*(dy-dx) ;


Iterate over all columns:

for (x = x_start , y = y_start ; x < x_end ; x++)

{WritePixel (x,y) ;if (d <= 0)

d += incr_L ;else{ d += incr_H ;

y++ ;}

}

Putting it all together:



Endpoint OrderIf all pixels along the line are set, adjacent line segements will touch first/last pixel multiple times

Creates problems with some pixel algorithms, e.g. transparency

Therefore, typically the first/last is not drawn


Scan Conversion of Triangles (1)Scan Conversion of Triangles (1)

Determine all pixels that belong to a trianglePoint sampling: Generate only pixels with center inside the trianglePixels exactly on the triangle border require special tie-breaker ruleThis ensures that a pixel is not touched twice by adjacent trianglesRasterization rules for triangles and lines are different



Triangles are scan converted by finding the limits of covered spans

A span is a continuous, horizontal range of pixelsStarting and ending pixels are computed incrementallyEdge slopes are represented with floating-point or fixed-point numbers

Pixels in between the edge pixels are filled in


Scan Conversion for Triangles (3)Scan Conversion for Triangles (3)Computing the edge pixels:

Compute X-coordinates of edge in current scanlineIncrementally computed using edge slopes dx/dyIncrementally computed using edge slopes dx/dy

Adjust this coordinate to get the pixel inside the triangleLeft edge: nudge to the right --- Right edge: nudge to the leftLeft edge: nudge to the right --- Right edge: nudge to the left

x x

x xS L

E R

==

EL ER

xExSxL xR

yi

yi+1

dx /dyL dx /dyR



Non-integer coordinates and slopesThe application or clipping may produce vertices that do not fall onto pixel centersHowever, in screen coordinates all quantities are represented on a fixed gridSlopes are therefore always rational numbers, i.e. ratio of numbers on that fixed grid

Numbers are represented using a fixed-point representationVertex positions and slopesVertex positions and slopes

Number of integer bits determined by the number of grid positionsNumber of fractional bits is determined by smallest slope



Tie-breaker ruleInclude pixels on a top edgeInclude pixel on a triangle vertex, if the vertex is the right vertex of the edge and does not lie below the left vertex (top-right vertex)Still does not catch all possible (pathological) cases



Computing interior pixelsIterate from starting pixel to ending pixel: for (x=xS ; x<=xE ; x++) setpixel (x, yi) ;



Triangle Terminology

BottomHalf

TopHalf

Leading Edge

Trailing Edge

TrailingEdge

MiddleVertex

Top Vertex

Bottom Vertex


Left Triangle Right Triangle Top Triangle Bottom Triangle

Triangle Types




Initialization:

// Determine leading edge// & midpoint of trailing edgex_top = ... ; y_top = ... ;x_bot = ... ; y_bot = ... ;x_mid = ... ; y_mid = ... ;

slope_lead = ... ;slope_trail1 = ... ;slope_trail2 = ... ;

Iterate (only top half):

x_lead = x_trail = x_top ;slope_trail = slope_trail1 ;

for (y=y_top, y < y_mid ; y++){ xs = ceil(x_lead) ; xe = floor(x_trail) ;

setpixel (xs, y) ;for (x=xs ; x < xe ; x++)

setpixel (x,y) ;x_lead += slope_lead ;x_trail += slope_trail ;

}

Putting it all together (for left-triangle):



So far, we have answered the question: Which pixels are in the triangle ?

Direct computation of the rasterization

Conversly, we could have also asked:Is this pixel inside the triangle ?

Point-in-triangle Test



A triangle is the intersection of 3 half-planes

Each half-plane is limited by an oriented line ax+by+c = 0

Same algorithm works for all convex polygons

0

1

2

3

4

5

6

Y

0 1 2 3 4 5 6X

L1L2

L3

+0.0+4.2 -1.0

+1.0+3.5 -1.0

+2.0+2.8 -1.0

+3.0+2.1 -1.0

+4.0+1.4 -1.0

+5.0+0.7 -1.0

-1.0+4.9 -1.0

+0.0+3.5+0.0

+1.0+2.8+0.0

+2.0+2.1+0.0

+3.0+1.4+0.0

+4.0+0.7+0.0

+5.0+0.0+0.0

-1.0+4.2+0.0

+0.0+2.8+1.0

+1.0+2.1+1.0

+2.0+1.4+1.0

+3.0+0.7+1.0

+4.0+0.0+1.0

+5.0 -0.7+1.0

-1.0+3.5+1.0

+0.0+2.1+2.0

+1.0+1.4+2.0

+2.0+0.7+2.0

+3.0+0.0+2.0

+4.0 -0.7+2.0

+5.0 -1.4+2.0

-1.0+2.8+2.0

+0.0+1.4+3.0

+1.0+0.7+3.0

+2.0+0.0+3.0

+3.0 -0.7+3.0

+4.0 -1.4+3.0

+5.0 -2.1+3.0

-1.0+2.1+3.0

+0.0+0.7+4.0

+1.0+0.0+4.0

+2.0 -0.7+4.0

+3.0 -1.4+4.0

+4.0 -2.1+4.0

+5.0 -2.8+4.0

-1.0+1.4+4.0

+0.0+0.0+5.0

+1.0 -0.7+5.0

+2.0 -1.4+5.0

+3.0 -2.1+5.0

+4.0 -2.8+5.0

+5.0 -3.5+5.0

-1.0+0.7+5.0

L1: 0 = 0x + 1y -1

L2: 0 = 1x + 0y -1

L3: 0 = -5/7x + 5/7y +5


Scan Conversion of PolygonsScan Conversion of Polygons


Scan Conversion of PolygonsScan Conversion of Polygons

General polygons differ from trianglesNot always convexMay have holesCan be self-intersectingGenerally not planar

ApproachesDivide & Conquer: Triangulate the polygon before scan-conversion

Triangulation is a difficult problem alsoTriangulation is a difficult problem also

Direct rasterization


Scan Conversion of Polygons: OverviewScan Conversion of Polygons: Overview

Extension of the triangle scan conversion algorithmWorks for many classes of polygons, including concave, self-intersecting polygons as well as polygons with interior holes

Determine spans of pixels that are inside the polygonSimilar to triangle rasterization, we use tie-breaker rules to avoid writing a pixel twice by adjacent polygons

Calculate the spans' start and end points incrementallyCalculate the intersection of polygon edges with scan lines


Scan Conversion of Polygons: ExampleScan Conversion of Polygons: Example


Scan Conversion of Polygons: TerminologyScan Conversion of Polygons: Terminology

Active edge (AE)An edge that intersects the current scanline

SpanContinuous set along a scanline

Leading/trailing edgeEdge defining the left/right end of a span


Scan Conversion of Polygons:Scan Conversion of Polygons:Basic AlgorithmBasic Algorithm

Intersect all edges with the current scanline

This will determine the set of active edges

Sort all intersection by increasing x and mark as leading or trailing edge

Compute starting and ending pixel coordinates

Round X up/down for leading/trailing edge

Fill pixels for all spans defined by a pair of leading/trailing edges


Scan Conversion of Polygons:Scan Conversion of Polygons:Special Cases (1)Special Cases (1)

Horizontal EdgesNo (unique) intersection with the scanlineIgnore. Let adjacent, non-horizontal edges take care of pixels on horizontal edges. Use tie-breaker rules.


Scan Conversion of Polygons:Scan Conversion of Polygons:Special Cases (2)Special Cases (2)

Clipped PolygonsClipping can generate half-open spansLeftmost edge-scanline intersection may be a trailing edge and/or rightmost may be a leading edgeIf leftmost pixel is outside (inside) the first intersection is a leading (trailing) edgeThen alternate between leading and trailing edge


Scan Conversion of Polygons: Scan Conversion of Polygons: Implementation (1)Implementation (1)

Simple-minded computation of intersection between edges and scanlines can be inefficient (slow)

Often, only a few edges intersect the active scanlineNeighboring scanlines tend to be intersected by the same edges (edge coherence)

Determination of active edges can be optimizedIncrementally compute the intersection with the next scanline from the intersection point with the current scanline (see textbook Fig. 3.26)Maintain a global edge table (ET) containing all edgesMaintain an active edge table (AET) containing all edges intersecting the active scanlineUpdate the ET and AET for every new scanline


Scan Conversion of Polygons: Scan Conversion of Polygons: Implementation (2)Implementation (2)

Edge Table (ET)Bucket sorted list of all edges, with a bucket for each scanlineEdges are sorted by their minimum (maximum) Y-coordinate

Active Edge Table (AET)List of edges intersecting the current scanlineSorted by increasing X-coordinate of the intersectionFor each new scanline Y

Update X coordinate of intersection for active edgesUpdate X coordinate of intersection for active edgesInsert edges from the ET into the AET that become active, i.e. for which YInsert edges from the ET into the AET that become active, i.e. for which YMINMIN = Y = Y Remove edges from the AET that are no longer active, i.e. for which YRemove edges from the AET that are no longer active, i.e. for which YMAXMAX = Y= YResort AETResort AETCompute starting and ending coordinates for spans defined by the active edgesCompute starting and ending coordinates for spans defined by the active edgesFill in pixel spansFill in pixel spans


Attribute InterpolationAttribute Interpolation


Attribute InterpolationAttribute Interpolation

So far, we have only determined which pixels are covered by a primitive

Pixel values are determined by primitive attributesAttributes can be computed different ways, but most common is linear or bilinear interpolation based on values at the verticesIn the following, we will treat a generic attribute AColor, Texture, Normal vector, Transparency, ...Each component is interpolated individuallyCan be applied to lines, triangles and polygons


Linear Interpolation (1)Linear Interpolation (1)

Attribute defined at the verticesA(x,y) defines a plane in x-y-A space

A =01

A =0.252

A =13

x

A

0.125

0.75



Computing linear interpolationAttribute value is a linear function in x, yA(x,y) = ax + by + ca describes the change from x to x+1, a.k.a. x gradient or x slopeb describes the change from y to y+1, a.k.a. y gradient or y slopec is the value of A at the origin

Computing the parametersSystem of linear equations:Solve using preferred methodE.g. Cramer's rule

x yx yx y

abc

AAA

1 1

2 2

3 3

1

2

3

111

FHGG

IKJJ⋅

FHGG

IKJJ=

FHGG

IKJJ


a

A yA yA yx yx yx y

A y y A y y A y yx y y x y y x y y

bA x x A x x A x x

x y y x y y x y y

cx A y A y x A y A y

= = − − − + −− − − + −

= − − + − − −− − − + −

= − − −

1 1

2 2

3 3

1 1

2 2

3 3

1 2 3 2 1 3 3 1 2

1 2 3 2 1 3 3 1 2

1 2 3 2 1 3 3 1 2

1 2 3 2 1 3 3 1 2

1 3 2 2 3 2 3 1 1 3

111111

( ) ( ) ( )( ) ( ) ( )

( ) ( ) ( )( ) ( ) ( )

( ) ( ) + −− − − + −

x A y A yx y y x y y x y y

3 2 1 1 2

1 2 3 2 1 3 3 1 2

( )( ) ( ) ( )



Bilinear Interpolation (1)Bilinear Interpolation (1)

Attribute defined at verticesA(x,y) defines piecewise linear in x-y-A spaceGenerally, not rotation-invariant !!

A =01

A =03A =12

A =14

x

A

0.5

1.0


Bilinear Interpolation (2)Bilinear Interpolation (2)

Interpolate attribute along starting and trailing edgeUse algorithms developed earlier for scan conversionUse constant dA/dy for each edge (a.k.a. edge slope)Adjust attribute to pixel centers

Interpolate attribute along scanline between starting and trailing edge pixels

Compute dA/dx for each span (a.k.a. x-gradient or x-slope)

Integrates nicely with scanline rasterization algorithms


Linear vs. Bilinear InterpolationLinear vs. Bilinear Interpolation

Linear interpolation only defined over triangles

4+ vertices need higher-order polynomial interpolation

Bilinear interpolation provides a piece-wise linear approximation to this polynomial

Bilinear interpolation fits with scanline rasterization

Bilinear interpolation is not rotation-invariant

Rotation invariance can be ensured by triangulation


Perspective Projection (1)Perspective Projection (1)

Perspective projection plays havoc with linearly interpolated parameter values

Non-linear mapping of depth values also affects attributesAttribute ranges is compressed with increasing distance

Eye

A=0

A=1

A=0.5A’=0

A’=1A’=0.41



This effect has been overlooked a long time because it was not very apparent with Gouraud / Phong shadingTexture mapping makes these errors very noticable

Linear interpolation after perspective projection generates the wrong attribute values

u=0 u=1v=0

v=1

Linear Interpolation Hyperbolic Interpolation



Attributes are defined at the vertices in object coordinates (eye or world coordinates)Attribute interpolation occurs in screen coordinates, i.e. after the perspective division

The attribute values at the vertices are correct by constructionLinear interpolation of attributes produces wrong values

Problem:Given a point in screen coordinates, what is the attribute value corresponding to this point ?For this we need to find out which attribute value belongs to this point in object space.



P x y zO O O OT= , , ,1b gPoints in object space:

Points in clip space:

Points in screen space:

Determine perspective transformation and division affect a point's representation.

P x y zS S S ST= , , ,1b g

P x y z wC C C C CT= , , ,b g



Going from object space to screen space:

Going back from screen space to object space:

Note: M and M-1 are perspective matrices, i.e. they both change the w componentTilde notation indicates that w != 1.

P x y z P x y z w Pxw

yw

zwO O O O

TC C C C C

T w

SC

C

C

C

C

C

T

= = = FHG

IKJ→ →, , , ~ , , , , ,1

1

b g b g M

~ , , , , , , , ,P x w y w z w w P x y z P x y zO O O O O O O OT

C S S ST

S S S ST= = =

−

← ←b g b g b g M 1

1



To determined the objects space point PO correspoding to the point PS in screen space, PS must be transformed by the inverse of M.

A full matrix-point multiplication for every pixel is very expensiveThere is a better way ...

~P PPw

Pw

PwO S

C

C

O

C

O

C

= ⋅ = ⋅ = ⋅ ⋅ =− − −M M MM1 1 1

~ , , , , , ,

/

P x w y w z w wxw

yw

zw w

w w

O O O O O O O OT O

C

O

C

O

C C

T

O C

= = FHG

IKJ

⇒ =

b g 1

1



Now, let's look what happens to the attributes:

Object coordinates are mapped linearly to attributes

Attributes are interpolated in screen space:

Similarly, points are generated by linear interpolation in screen space:

A A t A AS = + ⋅ −1 2 1b g

P P t P PS = + ⋅ −1 2 1b g

A ax by cz d a b c d x y z N PO O O OT

O O OT

O= + + + = • = •, , , , , ,b g b g1



Object-space attributes and screen-space points are related:

We define screen-space attributes asScreen-space attributes are proportional to screen points PS, because M is affine

Therefore:

A N P NPw w

N PO OO

O OO= • = • = ⋅ •

~~1

A N PS O= •~

Aw

AOO

S= 1



Recall

For a given point in screen space, the attribute values are therefore:

What does that mean ?Initialize AS to AO / wC at the verticesInterpolate AS and 1/wC, then divide by 1/wC at every pixel

A N PN P

wAw

AAw

Aw

S OO

C

O

C

OS

O

S

C

= • = • =

= =

~

/1

P P wO O O= ~ / w wO C= 1 /



AO = AS / 1/wC

To obtain the proper attribute value, the value obtained by linear interpolation in screen space must be divided by the value of the interpolate 1/w-component.The 1/w-component itself, is also obtained by linear interpolation in screen space

Numerator and denominator are linear function in screen X and YAO is rational functionThe computation is a hyperbolic interpolation

AAw

ax by cdx ey fO

S

C

S S

S S

= = + ++ +1 /



SummaryBoth attributes and 1/W component are interpolated separately

Proper interpolation of parameters requires division at every pixel of interpolated attribute value and interpolated 1/W

This a very costly operation that can be avoided for shading but must be performed for texture mapping

Alternative:Subdivision of the surface to introduce more points over the surface that have the correct attribute value. Then the maximum error is reduced and linear interpolation becomes acceptable.


SummarySummary

Scan Conversion determines which pixels are covered by a primitivePrimitive scan conversion must determine integer pixel coordinatesScan Conversion is usually done incrementally, exploiting coherence between pixels, scanlines, edges

Various algorithms for specific primitive types:Point, lines, triangles, polygons

Attribute interpolation assigns pixel valuesTypically also done incrementally using (bi)linear expressionsAttention: perspective projection requires special treatment


Short Overview of 2nd AssignmentShort Overview of 2nd Assignment

Apply your knowledge about viewing, clipping and scan-conversion

Read polygons descriptions from fileDisplay them unclipped as wireframeDisplay them clipped against a clip volume as filled polysScan-convert them to a virtual raster screen and display this raster in front of the clip volumeProvide view manipulation

Screen RectanglePixel Rectangle

Polygon

Clip Volume

Clipped Polygon


HomeworkHomework

Review primitive scan conversion in textbookAlso look at circle and ellipsis scan conversion

Prepare for fragment processing discussion next weekRead OpenGL Programming Manual re Anti-aliasing and Fragment Processing (chapters 6, 9 and 10)Foley et al., chapters 3.8, 14.10, 15.4, 19.3

Study hidden-surface algorithmsZ-buffering, Depth-sorting algorithm, Scanline algorithmsFoley et al., chapters 15.2, 15.4, 15.5.1, 15.6


Next Week ...Next Week ...

Fragment Processing

Hidden-Surface Removal

Texture Map

Pixel

Texture map

u

v

0 10

1(0.0, 0.8)

(0.8, 0.8)

(0.4, 0.2)

S(u ,v )1 1 S(u ,v )2 1

S(u ,v )2 2S(u ,v )1 2

u1

v1

v2

u2

computer graphics - week 6

Documents