prev

next

of 325

Published on

25-Dec-2015View

223Download

1

Transcript

- Slide 1
- UNIT- I 2D PRIMITIVES
- Slide 2
- Line and Curve Drawing Algorithms
- Slide 3
- Line Drawing y = m. x + b m = (y end y 0 ) / (x end x 0 ) b = y 0 m. x 0 x0x0 y0y0 x end y end
- Slide 4
- DDA Algorithm if |m|1 y k+1 = y k + 1 x k+1 = x k + 1/m x0x0 y0y0 x end y end x0x0 y0y0 x end y end
- Slide 5
- DDA Algorithm #include inline int round (const float a) { return int (a + 0.5); } void lineDDA (int x0, int y0, int xEnd, int yEnd) { int dx = xEnd - x0, dy = yEnd - y0, steps, k; float xIncrement, yIncrement, x = x0, y = y0; if (fabs (dx) > fabs (dy)) steps = fabs (dx);/* |m|=1 */ xIncrement = float (dx) / float (steps); yIncrement = float (dy) / float (steps); setPixel (round (x), round (y)); for (k = 0; k < steps; k++) { x += xIncrement; y += yIncrement; setPixel (round (x), round (y)); }
- Slide 6
- Bresenhams Line Algorithm xkxk ykyk x k+1 y k+1 y dudu dldl xkxk x k+1 ykyk y k+1
- Slide 7
- Bresenhams Line Algorithm #include /* Bresenham line-drawing procedure for |m| xEnd) { x = xEnd; y = yEnd; xEnd = x0; } else { x = x0; y = y0; } setPixel (x, y); while (x < xEnd) { x++; if (p < 0) p += twoDy; else { y++; p += twoDyMinusDx; } setPixel (x, y); }
- Slide 8
- Circle Drawing Pythagorean Theorem: x 2 + y 2 = r 2 (x-x c ) 2 + (y-y c ) 2 = r 2 (x c -r) x (x c +r) y = y c r 2 - (x-x c ) 2 xcxc ycyc r (x, y)
- Slide 9
- Circle Drawing change x change y
- Slide 10
- Circle Drawing using polar coordinates x = x c + r. cos y = y c + r. sin change with step size 1/r r (x, y) (x c, y c )
- Slide 11
- Circle Drawing using polar coordinates x = x c + r. cos y = y c + r. sin change with step size 1/r use symmetry if >45 0 r (x, y) (x c, y c ) (x, y) (x c, y c ) 45 0 (y, x)(y, -x) (-x, y)
- Slide 12
- Midpoint Circle Algorithm f(x,y) = x 2 + y 2 - r 2
- Inside-Outside test When is a point an interior point? Odd-Even Rule Draw conceptually a line from a specified point to a distant point outside the coordinate space; count the number of polygon edges that are crossed if odd => interior if even => exterior Note! The vertices!
- Slide 67
- Text Representation: * bitmapped (raster) + fast - more storage - less good for styles/sizes * outlined (lines and curves) + less storage + good for styles/sizes - slower
- Slide 68
- Other output primitives * pattern (to fill an area) normally, an n x m rectangular color pixel array with a specified reference point * polymarker (marker symbol) a character representing a point * (polyline) a connected sequence of line segments
- Slide 69
- Attributes Influence the way a primitive is displayed Two main ways of introducing attributes: 1) added to primitives parameter list e.g. setPixel(x, y, color) 2) a list of current attributes (to be updated when changed) e.g setColor(color); setPixel(x, y);
- Slide 70
- Attributes for lines Lines (and curves) are normally infinitely thin type dashed, dotted, solid, dot-dashed, pixel mask, e.g. 11100110011 width problem with the joins; line caps are used to adjust shape pen/brush shape color (intensity)
- Slide 71
- Lines with width Line caps Joins
- Slide 72
- Attributes for area fill fill style hollow, solid, pattern, hatch fill, color pattern tiling
- Slide 73
- Tiling Tiling = filling surfaces (polygons) with a rectangular pattern
- Slide 74
- Attributes for characters/strings style font (typeface) color size (width/height) orientation path spacing alignment
- Slide 75
- Text attributes
- Slide 76
- Text attributes, contd
- Slide 77
- Slide 78
- Slide 79
- Color as attribute Each color has a numerical value, or intensity, based on some color model. A color model typically consists of three primary colors, in the case of displays Red, Green and Blue (RGB) For each primary color an intensity can be given, either 0-255 (integer) or 0-1 (float) yielding the final color 256 different levels of each primary color means 3x8=24 bits of information to store
- Slide 80
- Color representations Two different ways of storing a color value: 1) a direct color value storage/pixel 2) indirectly via a color look-up table index/pixel (typically 256 or 512 different colors in the table)
- Slide 81
- Color Look-up Table
- Slide 82
- Antialiasing Aliasing the fact that exact points are approximated by fixed pixel positions Antialiasing = a technique that compensates for this (more than one intensity level/pixel is required)
- Slide 83
- Antialiasing, a method A polygon will be studied (as an example). Area sampling (prefiltering): a pixel that is only partly included in the exact polygon, will be given an intensity that is proportional to the extent of the pixel area that is covered by the true polygon
- Slide 84
- Area sampling P = polygon intensity B = background intensity f = the extent of the pixel area covered by the true polygon pixel intensity = P*f + B*(1 - f) Note! Time consuming to calculate f
- Slide 85
- Topics Clipping Cohen-Sutherland Line Clipping Algorithm
- Slide 86
- Clipping Why clipping? Not everything defined in the world coordinates is inside the world window Where does clipping take place? OpenGL does it for you BUT, as a CS major, you should know how it is done. Model Viewport Transformation Clipping
- Slide 87
- Line Clipping int clipSegment(p1, p2, window) Input parameters: p1, p2, window p1, p2: 2D endpoints that define a line window: aligned rectangle Returned value: 1, if part of the line is inside the window 0, otherwise Output parameters: p1, p2 p1 and/or p2s value might be changed so that both p1 and p2 are inside the window
- Slide 88
- Line Clipping Example Line RetVal Output AB BC CD DE EA o P1 o P2 o P3 o P4 o P1 o P2 o P3 o P4
- Slide 89
- Cohen-Sutherland Line Clipping Algorithm Trivial accept and trivial reject If both endpoints within window trivial accept If both endpoints outside of same boundary of window trivial reject Otherwise Clip against each edge in turn Throw away clipped off part of line each time How can we do it efficiently (elegantly)?
- Slide 90
- Cohen-Sutherland Line Clipping Algorithm Examples: trivial accept? trivial reject? window L1 L2 L3 L4 L5 L6
- Slide 91
- Cohen-Sutherland Line Clipping Algorithm Use region outcode
- Slide 92
- Cohen-Sutherland Line Clipping Algorithm outcode[1] (x < Window.left) outcode[2] (y > Window.top) outcode[3] (x > Window.right) outcode[4] (y < Window.bottom)
- Slide 93
- Cohen-Sutherland Line Clipping Algorithm Both outcodes are FFFF Trivial accept Logical AND of two outcodes FFFF Trivial reject Logical AND of two outcodes = FFFF Cant tell Clip against each edge in turn Throw away clipped off part of line each time
- Slide 94
- Cohen-Sutherland Line Clipping Algorithm Examples: outcodes? trivial accept? trivial reject? window L1 L2 L3 L4 L5 L6
- Slide 95
- Cohen-Sutherland Line Clipping Algorithm int clipSegment(Point2& p1, Point2& p2, RealRect W) do if(trivial accept) return 1; else if(trivial reject) return 0; else if(p1 is inside) swap(p1, p2) if(p1 is to the left) chop against the left else if(p1 is to the right) chop against the right else if(p1 is below) chop against the bottom else if(p1 is above) chop against the top while(1);
- Slide 96
- Cohen-Sutherland Line Clipping Algorithm A segment that requires 4 clips
- Slide 97
- Cohen-Sutherland Line Clipping Algorithm How do we chop against each boundary? Given P1 (outside) and P2, (A.x,A.y)=?
- Slide 98
- Cohen-Sutherland Line Clipping Algorithm Let dx = p1.x - p2.xdy = p1.y - p2.y A.x = w.r d = p1.y - A.y e = p1.x - w.r d/dy = e/dx p1.y - A.y = (dy/dx)(p1.x - w.r) A.y = p1.y - (dy/dx)(p1.x - w.r) = p1.y + (dy/dx)(w.r - p1.x) As A is the new P1 p1.y += (dy/dx)(w.r - p1.x) p1.x = w.r Q: Will we have divided-by-zero problem?
- Slide 99
- UNIT-II THREE- DIMENSIONAL CONCEPTS
- Slide 100
- 3D VIEWING
- Slide 101
- 3D Viewing-contents Viewing pipeline Viewing coordinates Projections View volumes and general projection transformations clipping
- Slide 102
- 3D Viewing World coordinate system(where the objects are modeled and defined) Viewing coordinate system(viewing objects with respect to another user defined coordinate system) Scene coordinate system(a viewing coordinate system chosen to be at the centre of a scene) Object coordinate system(a coordinate system specific to an object.)
- Slide 103
- 3D viewing Simple camera analogy is adopted
- Slide 104
- 3D viewing-pipeline
- Slide 105
- 3D viewing Defining the viewing coordinate system and specifying the view plane
- Slide 106
- 3D viewing First pick up a world coordinate position called the view reference point. This is the origin of the VC system Pick up the +ve direction for the Z v axis and the orientation of the view plane by specifying the view plane normal vector N. Choose a world coordinate position and this point establishes the direction for N relative to either the world or VC origin. The view plane normal vector is the directed line segment. steps to establish a Viewing coordinate system or view reference coordinate system and the view plane
- Slide 107
- 3D viewing steps to establish a Viewing coordinate system or view reference coordinate system and the view plane Some packages allow us to choose a look at point relative to the view reference point. Or set up a Left handed viewing system and take the N and the +ve Z v axis from the viewing origin to the look- at point.
- Slide 108
- 3D viewing steps to establish a Viewing coordinate system or view reference coordinate system and the view plane We now choose the view up vector V. It can be specified as a twist angle about Z v axis. Using N,V U can be specified. Generally graphics packages allow users to choose a position of the view plane along the Z v axis by specifying the view plane distance from the viewing origin. The view plane is always parallel to the X v Y v plane.
- Slide 109
- 3D viewing To obtain a series of views of a scene we can keep the view reference point fixed and change the direction of N or we can fix N direction and move the view reference point around the scene.
- Slide 110
- 3D viewing (a) Invert Viewing z Axis (b) Translate Viewing Origin to World Origin (c) Rotate About World x Axis to Bring Viewing z Axis into the xz Plane of the World System (d) Rotate About the World y Axis to Align the Two z Axes (e) Rotate About the World z Axis to Align the Two Viewing Systems Transformation from world to viewing coordinate system M wc,vc =R z R y R x.T
- Slide 111
- What Are Projections? Picture Plane Objects in World Space Our 3-D scenes are all specified in 3-D world coordinates To display these we need to generate a 2-D image - project objects onto a picture plane
- Slide 112
- Converting From 3-D To 2-D Projection is just one part of the process of converting from 3-D world coordinates to a 2-D image Clip against view volume Project onto projection plane Transform to 2-D device coordinates 3-D world coordinate output primitives 2-D device coordinates
- Slide 113
- Types Of Projections There are two broad classes of projection: Parallel: Typically used for architectural and engineering drawings Perspective: Realistic looking and used in computer graphics Perspective Projection Parallel Projection
- Slide 114
- Taxonomy Of Projections
- Slide 115
- Types Of Projections There are two broad classes of projection: Parallel: preserves relative proportions of objects accurate views of various sides of an object can be obtained does not give realistic representations of the appearance of a 3D objective. Perspective: produce realistic views but does not preserve relative proportions projections of distant objects are smaller than the projections of objects of the same size that are closer to the projection plane.
- Slide 116
- Parallel Projections Some examples of parallel projections Orthographic Projection(axonometric) Orthographic oblique
- Slide 117
- Parallel Projections Some examples of parallel projections Isometric projection for a cube The projection plane is aligned so that it intersects each coordinate axes in which the object is defined (principal axes) at the same distance from the origin. All the principal axes are foreshortened equally.
- Slide 118
- Parallel Projections Transformation equations for an orthographic parallel projections is simple Any point (x,y,z) in viewing coordinates is transformed to projection coordinates as Xp=XYp=Y
- Slide 119
- Parallel Projections Transformation equations for oblique projections is as below. Oblique projections
- Slide 120
- Parallel Projections Transformation equations for oblique projections is as below. Oblique projections An orthographic projection is obtained when L1=0. In fact the effect of the projection matrix is to shear planes of constant Z and project them on to the view plane. Two common oblique parallel projections: Cavalier and Cabinet
- Slide 121
- Parallel Projections Oblique projections 2 common oblique parallel projections: Cavalier projection Cabinet projection All lines perpendicular to the projection plane are projected with no change in length. They are more realistic than cavaliar Lines perpendicular to the viewing surface are projected at one-half their length.
- Slide 122
- Perspective Projections visual effect is similar to human visual system... has 'perspective foreshortening size of object varies inversely with distance from the center of projection. angles only remain intact for faces parallel to projection plane.
- Slide 123
- Perspective Projections Where u varies from o to 1
- Slide 124
- Perspective Projections
- Slide 125
- If the view plane is the UV plane itself then Zvp=0. The projection coordinates become Xp=X(Zprp/(Zprp-Z))=X(1/(1-Z/Zprp)) Yp=Y(Zprp/(Zprp-Z))=Y(1/(1-Z/Zprp)) If the PRP is selected at the viewing cooridinate origin then Zprp=0 The projection coordinates become Xp=X(Zvp/Z) Yp=Y(Zvp/Z)
- Slide 126
- Perspective Projections There are a number of different kinds of perspective views The most common are one-point and two point perspectives One-point perspective projection Two-point perspective projection Coordinate description
- Slide 127
- Perspective Projections Parallel lines that are parallel to the view plane are projected as parallel lines. The point at which a set of projected parallel lines appear to converge is called a vanishing point. If a set of lines are parallel to one of the three principle axes, the vanishing point is called an principal vanishing point. There are at most 3 such points, corresponding to the number of axes cut by the projection plane.
- Slide 128
- View volume
- Slide 129
- Perspective projection Parallel projection The size of the view volume depends on the size of the window but the shape depends on the type of projection to be used. Both near and far planes must be on the same side of the reference point.
- Slide 130
- View volume Often the view plane is positioned at the view reference point or on the front clipping plane while generating parallel projection. Perspective effects depend on the positioning of the projection reference point relative to the view plane
- Slide 131
- Front Clipping Plane View Plane Back Clipping Plane Direction of Propagation Front Clipping Plane View Plane Back Clipping Plane Direction of Propagation Front Clipping Plane View Plane Back Clipping Plane View volume - PHIGS
- Slide 132
- View volume In an animation sequence, we can place the projection reference point at the viewing coordinate origin and put the view plane in front of the scene. We set the field of view by adjusting the size of the window relative to the distance of the view plane from the PRP. We move through the scene by moving the viewing reference frame and the PRP will move with the view reference point.
- Slide 133
- Direction of Projection Near Plane Far Plane Window (a) Original Orientation (b) After Shearing Direction of Projection Window Near Plane Far Plane View Volume View Volume Parallel General parallel projection transformation
- Slide 134
- Shearing Let V p =(a,b,c) be the projection vector in viewing coordinates. The shear transformation can be expressed as V p =M parallel.V p Where M parallel is For an orthographic parallel projection M parallel becomes the identity matrix since a 1 =b 1 =0 Parallel
- Slide 135
- Perspective View Volume View Volume Far Near Window Far Near Window Center of Projection Center of Projection (a) Original Orientation (b) After Transformation Shearing Regularization of Clipping (View) Volume (Cont ) General perspective projection transformation
- Slide 136
- Perspective Steps 1.Shear the view volume so that the centerline of the frustum is perpendicular to the view plane 2.Scale the view volume with a scaling factor that depends on 1/z. A shear operation is to align a general perspective view volume with the projection window. The transformation involves a combination of z-axis shear and a translation. M perspective =M scale.M shear
- Slide 137
- Clipping View volume clipping boundaries are planes whose orientations depend on the type of projection, the projection window and the position of the projection reference point The process of finding the intersection of a line with one of the view volume boundaries is simplified if we convert the view volume before clipping to a rectangular parallelepiped. i.e we first perform the projection transformation which converts coordinate values in the view volume to orthographic parallel coordinates. Oblique projection view volumes are converted to a rectangular parallelepiped by the shearing operation and perspective view volumes are converted with a combination of shear and scale transformations.
- Slide 138
- Clipping-normalized view volumes The normalized view volume is a region defined by the planes X=0, x=1, y=0, y=1, z=0, z=1
- Slide 139
- Clipping-normalized view volumes There are several advantages to clipping against the unit cube 1.The normalized view volume provides a standard shape for representing any sized view volume. 2.Clipping procedures are simplified and standardized with unit clipping planes or the viewport planes. 3.Depth cueing and visible-surface determination are simplified, since Z-axis always points towards the viewer. Unit cube 3D viewport Mapping positions within a rectangular view volume to a three-dimensional rectangular viewport is accomplished with a combination of scaling and translation.
- Slide 140
- Clipping-normalized view volumes Unit cube 3D viewport Mapping positions within a rectangular view volume to a three-dimensional rectangular viewport is accomplished with a combination of scaling and translation. Dx00Kx 0Dy0Ky 00DzKz 0001 Where D x =(xv max -xv min )/(xw max -xw min ) and K x = xv min - xw min D x D y = (yv max -yv min )/(yw max -yw min ) and K y = yv min - yw min D y D z = (zv max -zv min )/(zw max -zw min ) and K z = zv min - zw min D z
- Slide 141
- Viewport clipping For a line endpoint at position (x,y,z) we assign the bit positions in the region code from right to left as Bit 1 = 1 if x< xv min (left) Bit 1 = 1 if x< xv max (right) Bit 1 = 1 if y< yv min (below) Bit 1 = 1 if y< yv max (above) Bit 1 = 1 if z< zv min (front) Bit 1 = 1 if z< zv max (back)
- Slide 142
- Viewport clipping For a line segment with endpoints P1(x1,y1,z1) and P2(x2,y2,z2) the parametric equations can be X=x1+(x2-x1)u Y=y1+(y2-y1)u Z=z1+(z2-z1)u
- Slide 143
- Hardware implementations WORLD-COORDINATE Object descriptions Transformation Operations Clipping Operations Conversion to Device Coordinates
- Slide 144
- 3D Transformations 2D coordinates 3D coordinates x y x y z x z y Right-handed coordinate system:
- Slide 145
- 3D Transformations (cont.) 1.Translation in 3D is a simple extension from that in 2D: 2.Scaling is similarly extended:
- Slide 146
- 3D Transformations (cont.) 3.The 2D rotation introduced previously is just a 3D rotation about the z axis. similarly we have: X Y Z
- Slide 147
- Composition of 3D Rotations In 3D transformations, the order of a sequence of rotations matters!
- Slide 148
- More Rotations We have shown how to rotate about one of the principle axes, i.e. the axes constituting the coordinate system. There are more we can do, for example, to perform a rotation about an arbitrary axis: X Y Z P 2 (x 2, y 2, z 2 ) P 1 (x 1, y 1, z 1 ) We want to rotate an object about an axis in space passing through (x 1, y 1, z 1 ) and (x 2, y 2, z 2 ).
- Slide 149
- Rotating About An Arbitrary Axis Y Z P2P2 P1P1 1). Translate the object by (-x 1, - y 1, -z 1 ): T(-x 1, -y 1, -z 1 ) X Y Z P2P2 P1P1 2). Rotate the axis about x so that it lies on the xz plane: R x ( ) X X Y Z P2P2 P1P1 3). Rotate the axis about y so that it lies on z: R y ( ) X Y Z P2P2 P1P1 4). Rotate object about z by : R z ( )
- Slide 150
- Rotating About An Arbitrary Axis (cont.) After all the efforts, dont forget to undo the rotations and the translation! Therefore, the mixed matrix that will perform the required task of rotating an object about an arbitrary axis is given by: M = T(x 1,y 1,z 1 ) Rx(- )R y (- ) R z ( ) R y ( ) R x ( )T(-x 1,-y 1,-z 1 ) Finding is trivial, but what about ? The angle between the z axis and the projection of P 1 P 2 on yz plane is . X Y Z P2P2 P1P1
- Slide 151
- Composite 3D Transformations
- Slide 152
- Example of Composite 3D Transformations Try to transform the line segments P 1 P 2 and P 1 P 3 from their start position in (a) to their ending position in (b). The first solution is to compose the primitive transformations T, R x, R y, and R z. This approach is easier to illustrate and does offer help on building an understanding. The 2 nd, more abstract approach is to use the properties of special orthogonal matrices. y x z y x z P1P1 P2P2 P3P3 P1P1 P2P2 P3P3 (a) (b)
- Slide 153
- Composition of 3D Transformations Breaking a difficult problem into simpler sub-problems: 1.Translate P 1 to the origin. 2. Rotate about the y axis such that P 1 P 2 lies in the (y, z) plane. 3. Rotate about the x axis such that P 1 P 2 lies on the z axis. 4. Rotate about the z axis such that P 1 P 3 lies in the (y, z) plane. y x z y x z y x z P1P1 P2P2 P3P3 P1P1 P2P2 P3P3 y x z P1P1 P2P2 P3P3 y x z P1P1 P2P2 P3P3 P3P3 P2P2 P1P1 1 2 34
- Slide 154
- Composition of 3D Transformations 1. 2. y x z P1P1 P2P2 P3P3 D1D1
- Slide 155
- Composition of 3D Transformations 3 4. y x z P 1 P 2 D2D2 y x z P 1 P 2 D3D3 P 3 Finally, we have the composite matrix:
- Slide 156
- Vector Rotation x y x y Rotate the vector u The unit vector along the x axis is [1, 0] T. After rotating about the origin by , the resulting vector is
- Slide 157
- x Vector Rotation (cont.) y Rotate the vector x y v The above results states that if we try to rotate a vector, originally pointing the direction of the x (or y) axis, toward a new direction, u (or v), the rotation matrix, R, could be simply written as [u | v] without the need of any explicit knowledge of , the actual rotation angle. Similarly, the unit vector along the y axis is [0, 1] T. After rotating about the origin by , the resulting vector is
- Slide 158
- Vector Rotation (cont.) The reversed operation of the above rotation is to rotate a vector that is not originally pointing the x (or y) direction into the direction of the positive x or y axis. The rotation matrix in this case is R(- ), expressed by R -1 ( ) where T denotes the transpose. x x y y Rotate the vector u u
- Slide 159
- Example what is the rotation matrix if one wants the vector T in the left figure to be rotated to the direction of u. T (2, 3) u If, on the other hand, one wants the vector u to be rotated to the direction of the positive x axis, the rotation matrix should be
- Slide 160
- Rotation Matrices Rotation matrix is orthonormal: Each row is a unit vector Each row is perpendicular to the other, i.e. their dot product is zero. Each vector will be rotated by R( ) to lie on the positive x and y axes, respectively. The two column vectors are those into which vectors along the positive x and y axes are rotated. For orthonormal matrices, we have
- Slide 161
- Cross Product The cross product or vector product of two vectors, v 1 and v 2, is another vector: The cross product of two vectors is orthogonal to both Right-hand rule dictates direction of cross product. v1v1 v2v2 v1 v2v1 v2
- Slide 162
- u2u2 Extension to 3D Cases The above examples can be extended to 3D cases. In 2D, we need to know u, which will be rotated to the direction of the positive x axis. u v x y z u1u1 v=u 1 u 2 In 3D, however, we need to know more than one vector. See in the left figure, for example, two vectors, u 1 and u 2 are given. If after rotation, u 1 is aligned to the positive z axis, this will only give us the third column in the rotation matrix. What about the other two columns?
- Slide 163
- 3D Rotation In many cases in 3D, only one vector will be aligned to one of the coordinate axes, and the others are often not explicitly given. Lets see the example: y x z y x z P1P1 P2P2 P3P3 P1P1 P2P2 P3P3 Note, in this example, vector P 1 P 2 will be rotated to the positive z direction. Hence the fist column vector in the rotation matrix is the normalised P 1 P 2. But what about the other two columns? After all, P 1 P 3 is not perpendi- cular to P 1 P 2. Well, we can find it by taking the cross product of P 1 P 2 and P 1 P 3. Since P 1 P 2 P 1 P 3 is perpendicular to both P 1 P 2 and P 1 P 3, it will be aligned into the direction of the positive x axis.
- Slide 164
- And the third direction is decide by the cross product of the other two directions, which is P 1 P 2 (P 1 P 2 P 1 P 2 ). Therefore, the rotation matrix should be 3D Rotation (cont.) u y x z P1P1 P2P2 P3P3 v w y x z P1P1 P2P2 P3P3 u v
- Slide 165
- Yaw, Pitch, and Roll Imagine three lines running through an airplane and intersecting at right angles at the airplanes centre of gravity. Roll: rotation around the front-to-back axis. Roll: rotation around the side-to-side axis. Roll: rotation around the vertical axis.
- Slide 166
- An Example of the Airplane Consider the following example. An airplane is oriented such that its nose is pointing in the positive z direction, its right wing is pointing in the positive x direction, its cockpit is pointing in the positive y direction. We want to transform the airplane so that it heads in the direction given by the vector DOF (direction of flight), is centre at P, and is not banked.
- Slide 167
- Solution to the Airplane Example First we are to rotate the positive z p direction into the direction of DOF, which gives us the third column of the rotation matrix: DOF / |DOF|. The x p axis must be transformed into a horizontal vector perpendicular to DOF that is in the direction of y DOF. The y p direction is then given by x p z p = DOF (y DOF).
- Slide 168
- Inverses of (2D and) 3D Transformations 1.Translation: 2.Scaling: 3.Rotation: 4.Shear:
- Slide 169
- UNIT-III GRAPHICS PROGRAMMING
- Slide 170
- Color Models
- Slide 171
- Color models,contd Different meanings of color: painting wavelength of visible light human eye perception
- Slide 172
- Physical properties of light Visible light is part of the electromagnetic radiation (380- 750 nm) 1 nm (nanometer) = 10 -10 m (=10 -7 cm) 1 (angstrom) = 10 nm Radiation can be expressed in wavelength ( ) or frequency (f), c= f, where c=3. 10 10 cm/sec
- Slide 173
- Physical properties of light White light consists of a spectrum of all visible colors
- Slide 174
- Physical properties of light All kinds of light can be described by the energy of each wavelength The distribution showing the relation between energy and wavelength (or frequency) is called energy spectrum
- Slide 175
- Physical properties of light This distribution may indicate: 1) a dominant wavelength (or frequency) which is the color of the light (hue), cp. E D 2) brightness (luminance), intensity of the light (value), cp. the area A 3) purity (saturation), cp. E D - E W
- Slide 176
- Physical properties of light Energy spectrum for a light source with a dominant frequency near the red color
- Slide 177
- Material properties The color of an object depends on the so called spectral curves for transparency and reflection of the material The spectral curves describe how light of different wavelengths are refracted and reflected (cp. the material coefficients introduced in the illumination models)
- Slide 178
- Properties of reflected light Incident white light upon an object is for some wavelengths absorbed, for others reflected E.g. if all light is absorbed => black If all wavelengths but one are absorbed => the one color is observed as the color of the object by the reflection
- Slide 179
- Color definitions Complementary colors - two colors combine to produce white light Primary colors - (two or) three colors used for describing other colors Two main principles for mixing colors: additive mixing subtractive mixing
- Slide 180
- Additive mixing pure colors are put close to each other => a mix on the retina of the human eye (cp. RGB) overlapping gives yellow, cyan, magenta and white the typical technique on color displays
- Slide 181
- Subtractive mixing color pigments are mixed directly in some liquid, e.g. ink each color in the mixture absorbs its specific part of the incident light the color of the mixture is determined by subtraction of colored light, e.g. yellow absorbs blue => only red and green, i.e. yellow, will reach the eye (yellow because of addition)
- Slide 182
- Subtractive mixing,contd primary colors: cyan, magenta and yellow, i.e. CMY the typical technique in printers/plotters connection between additive and subtractive primary colors (cp. the color models RGB and CMY)
- Slide 183
- Additive/subtractive mixing
- Slide 184
- Human color seeing The retina of the human eye consists of cones (7-8M),tappar, and rods (100-120M), stavar, which are connected with nerve fibres to the brain
- Slide 185
- Human color seeing,contd Theory: the cones consist of various light absorbing material The light sensitivity of the cones and rods varies with the wavelength, and between persons The sum of the energy spectrum of the light the reflection spectrum of the object the response spectrum of the eye decides the color perception for a person
- Slide 186
- Overview of color models The human eye can perceive about 382000(!) different colors Necessary with some kind of classification sys- tem; all using three coordinates as a basis: 1) CIE standard 2) RGB color model 3) CMY color model (also, CMYK) 4) HSV color model 5) HLS color model
- Slide 187
- CIE standard Commission Internationale de LEclairage (1931) not a computer model each color = a weighted sum of three imaginary primary colors
- Slide 188
- RGB model all colors are generated from the three primaries various colors are obtained by changing the amount of each primary additive mixing (r,g,b), 0r,g,b1
- Slide 189
- RGB model,contd the RGB cube 1 bit/primary => 8 colors, 8 bits/primary => 16M colors
- Slide 190
- CMY model cyan, magenta and yellow are comple- mentary colors of red,green and blue, respectively subtractive mixing the typical printer technique
- Slide 191
- CMY model,contd almost the same cube as with RGB; only black white the various colors are obtained by reducing light, e.g. if red is absorbed => green and blue are added, i.e cyan
- Slide 192
- RGB vs CMY If the intensities are represented as 0r,g,b1 and 0c,m,y1 (also coordinates 0-255 can be used), then the relation between RGB and CMY can be described as:
- Slide 193
- CMYK model For printing and graphics art industry, CMY is not enough; a fourth primary, K which stands for black, is added. Conversions between RGB and CMYK are possible, although they require some extra processing.
- Slide 194
- HSV model HSV stands for Hue-Saturation-Value described by a hexcone derived from the RGB cube
- Slide 195
- HSV model,contd Hue (0-360); the color, cp. the dominant wave- length (128) Saturation (0-1); the amount of white (130) Value (0-1); the amount of black (23)
- Slide 196
- HSV model,contd The numbers given after each primary are estimates of how many levels a human being is capable to distinguish between, which (in theory) gives the total number of color nuances: 128*130*23 = 382720 In Computer Graphics, usually enough with: 128*8*15 = 16384
- Slide 197
- HLS model Another model similar to HSV L stands for Lightness
- Slide 198
- Color models Some more facts about colors: The distance between two colors in the color cube is not a measure of how far apart the colors are perceptionally! Humans are more sensitive to shifts in blue (and green?) than, for instance, in yellow
- Slide 199
- COMPUTER ANIMATIONS
- Slide 200
- Computer Animations Any time sequence of visual changes in a scene. Size, color, transparency, shape, surface texture, rotation, translation, scaling, lighting effects, morphing, changing camera parameters(position, orientation, and focal length), particle animation. Design of animation sequences: Storyboard layout Object definitions Key-frame specifications generation of in-between frames
- Slide 201
- Computer Animations Frame by frame animation Each frame is separately generated. Object defintion Objects are defined interms of basic shapes, such as polygons or splines. In addition the associated movements for each object are specified along with the shape. Storyboard It is an outline of the action Keyframe Detailed drawing of the scene at a particular instance
- Slide 202
- Computer Animations Inbetweens Intermediate frames (3 to 5 inbetweens for each two key frames) Motions can be generated using 2D or 3D transformation Object parameters are stored in database Rendering algorithms are used finally Raster animations: Uses raster operations. Ex: we can animate objects along 2D motion paths using the color table transformations. Here we predefine the object at successive positions along the motion path, and set the successive blocks of pixel values to color table entries
- Slide 203
- Computer Animations Computer animation languages: A typical task in animation specification is Scene description includes position of objects and light sources, defining the photometric parameters and setting the camera parameters. Action specification this involves layout of motion paths for the objects and camera. We need viewing and perspective transformations, geometric transformations, visible surface detection, surface rendering, kinematics etc., Keyframe systems designed simply to generate the in- betweens from the user specified key frames.
- Slide 204
- Computer Animations Computer animation languages: A typical task in animation specification is Parameterized systems allow object motion characteristics to be specified as part of the object definitions. The adjustable parameters control such object charateristics as degrees of freedom, motion limitations and allowable shape changes. Scripting systems allow object specifications and animation sequences to be defined with a user-input script. From the script a library of various objects and motions can be constructed.
- Slide 205
- Computer Animations Interpolation techniquesLinear
- Slide 206
- Computer Animations Interpolation techniques Non-linear
- Slide 207
- Key frame systems Morphing Transformation of object shapes from one form to another is called morphing. Given two keyframes for an object transformation, we first adjust the object specification in one of the frames so that number of polygon edges or vertices is the same for the two frames. Let L k,L k+1 denote the number of line segments in two different frames K,K+1 Let us define L max =max(L k,L k+1 ) L min =min(L k,L k+1 ) N e = L max mod L min N s = int(L max / L min ) Computer Animations 1 2 3 2 1 Key frame K Key frame K+1
- Slide 208
- Steps 1. Dividing N e edges of keyframe min into N s +1 sections 2. Dividing the remaining lines of keyframe min into N s sections Computer Animations 1 2 3 2 1 Key frame K Key frame K+1
- Slide 209
- Key frame systems Morphing Transformation of object shapes from one form to another is called morphing. If we equalize the vertex count, then the similar analysis follows Let V k,V k+1 denote the number of vertices in two different frames K,K+1 Let us define V max =max(L k,L k+1 ) V min =min(L k,L k+1 ) N ls = (V max 1)mod (V min 1) N p = int((V max 1) / (V min 1) Steps 1. adding N p points to N ls line sections of keyframe min sections 2. Adding N p -1 points to the remaining edges of keyframe min Computer Animations
- Slide 210
- Simulating accelerations Curve fitting techniques are often used to specify the animation paths between keyframes. To simulate accelerations we can adjust the time spacing for the in- betweens. For constant speed we use equal interval time spacing for the inbetweens. suppose we want n in-betweens for keyframes at times t1 and t2. The time intervals between key frames is then divided into n+1 sub intervals, yielding an in-between spacing of t = t2-t1/(n+1) We can calculate the time for in-betweens as tBj=t1+j t for j=1,2,.,n Computer Animations t
- Slide 211
- Simulating accelerations To model increase or decrease in speeds we use trignometric functions. To model increasing speed, we want the time spacing between frames to increase so that greater changes in position occur as the object moves faster. We can obtain increase in interval size with the function 1-cos ,0< < /2 For n-inbetweens the time for the jth inbetween would then be calculated as tBj=t1+ t(1-cosj /2(n+1)) j=1,2,.,n For j=1 tB1=t1+ t(1-cos /2(n+1)) For j=1 tB2=t1+ t(1-cos 2 /2(n+1)) where t is the time difference between any two key frames. Computer Animations
- Slide 212
- Simulating deccelerations To model increase or decrease in speeds we use trignometric functions. To model decreasing speed, we want the time spacing between frames to decrease. We can obtain increase in interval size with the function sin ,0< < /2 For n-inbetweens the time for the jth inbetween would then be calculated as tBj=t1+ t.sinj /2(n+1)) j=1,2,.,n Computer Animations
- Slide 213
- Simulating both accelerations and deccelerations To model increase or decrease in speeds we use trignometric functions. A combination of increasing and decreasing speeds can be modeled using (1-cos ) 0< < /2 The time for the jth inbetween is calculated as tBj=t1+ t 1-cos j[ (n+1)/2) j=1,2,.,n Computer Animations
- Slide 214
- Motion specifications Direct motion specifications Here we explicitly give the rotation angles and translation vectors. Then the geometric transformation matrices are applied to transform coordinate positions. A bouncing ball can be approximated by a sine curve y(x)=AI(sin( x+ 0 )Ie -kx A is the initial amplitude is the angular frequency 0 is the phase angle K is the damping constant Computer Animations
- Slide 215
- Motion specifications Goal directed systems We can specify the motions that are to take place in general terms that abstractly describe the actions, because they determine specific motion paramters given the goals of the animation. Computer Animations
- Slide 216
- Motion specifications Kinematics Kinematic specification of of a motion can also be given by simply describing the motion path which is often done using splines. In inverse kinematics we specify the intital and final positions of objects at specified times and the motion parameters are computed by the system. Computer Animations
- Slide 217
- Motion specifications dynamics specification of the forces that produce the velocities and accelerations. Descriptions of object behavior under the influence of forces are generally referred to as a Physically based modeling (.rigid body systems and non rigid systems such as cloth or plastic) Ex: magnetic, gravitational, frictional etc We can also use inverse dynamics to obtain the forces, given the initial and final position of objects and the type of motion. Computer Animations
- Slide 218
- Ideally suited for: Large volumes of objects wind effects, liquids, Cloth animation/draping Underlying mechanisms are usually: Particle systems Mass-spring systems Physics based animations
- Slide 219
- Computer Animations Physics based animations
- Slide 220
- Computer Animations Physics based animations
- Slide 221
- Computer Animations Some more animation techniques. Anticipation and Staging
- Slide 222
- Computer Animations Some more animation techniques. Secondary Motion
- Slide 223
- Computer Animations Some more animation techniques. Motion Capture
- Slide 224
- Computer Graphics using OpenGL Initial Steps in Drawing Figures
- Slide 225
- Using Open-GL Files:.h,.lib,.dll The entire folder gl is placed in the Include directory of Visual C++ The individual lib files are placed in the lib directory of Visual C++ The individual dll files are placed in C:\Windows\System32
- Slide 226
- Using Open-GL (2) Includes: (if used) Include in order given. If you use capital letters for any file or directory, use them in your include statement also.
- Slide 227
- Using Open-GL (3) Changing project settings: Visual C++ 6.0 Project menu, Settings entry In Object/library modules move to the end of the line and add glui32.lib glut32.lib glu32.lib opengl32.lib (separated by spaces from last entry and each other) In Project Options, scroll down to end of box and add same set of.lib files Close Project menu and save workspace
- Slide 228
- Using Open-GL (3) Changing Project Settings: Visual C++.NET 2003 Project, Properties, Linker, Command Line In the white space at the bottom, add glui32.lib glut32.lib glu32.lib opengl32.lib Close Project menu and save your solution
- Slide 229
- Getting Started Making Pictures Graphics display: Entire screen (a); windows system (b); [both have usual screen coordinates, with y-axis down]; windows system [inverted coordinates] (c)
- Slide 230
- Basic System Drawing Commands setPixel(x, y, color) Pixel at location (x, y) gets color specified by color Other names: putPixel(), SetPixel(), or drawPoint() line(x1, y1, x2, y2) Draws a line between (x1, y1) and (x2, y2) Other names: drawLine() or Line().
- Slide 231
- Alternative Basic Drawing current position (cp), specifies where the system is drawing now. moveTo(x,y) moves the pen invisibly to the location (x, y) and then updates the current position to this position. lineTo(x,y) draws a straight line from the current position to (x, y) and then updates the cp to (x, y).
- Slide 232
- Example: A Square moveTo(4, 4); //move to starting corner lineTo(-2, 4); lineTo(-2, -2); lineTo(4, -2); lineTo(4, 4); //close the square
- Slide 233
- Device Independent Graphics and OpenGL Allows same graphics program to be run on many different machine types with nearly identical output..dll files must be with program OpenGL is an API: it controls whatever hardware you are using, and you use its functions instead of controlling the hardware directly. OpenGL is open source (free).
- Slide 234
- Event-driven Programs Respond to events, such as mouse click or move, key press, or window reshape or resize. System manages event queue. Programmer provides call-back functions to handle each event. Call-back functions must be registered with OpenGL to let it know which function handles which event. Registering function does *not* call it!
- Slide 235
- Skeleton Event-driven Program // include OpenGL libraries void main() { glutDisplayFunc(myDisplay); // register the redraw function glutReshapeFunc(myReshape); // register the reshape function glutMouseFunc(myMouse); // register the mouse action function glutMotionFunc(myMotionFunc); // register the mouse motion function glutKeyboardFunc(myKeyboard); // register the keyboard action function perhaps initialize other things glutMainLoop(); // enter the unending main loop } all of the callback functions are defined here
- Slide 236
- Callback Functions glutDisplayFunc(myDisplay); (Re)draws screen when window opened or another window moved off it. glutReshapeFunc(myReshape); Reports new window width and height for reshaped window. (Moving a window does not produce a reshape event.) glutIdleFunc(myIdle); when nothing else is going on, simply redraws display using void myIdle() {glutPostRedisplay();}
- Slide 237
- Callback Functions (2) glutMouseFunc(myMouse); Handles mouse button presses. Knows mouse location and nature of button (up or down and which button). glutMotionFunc(myMotionFunc); Handles case when the mouse is moved with one or more mouse buttons pressed.
- Slide 238
- Callback Functions (3) glutPassiveMotionFunc(myPassiveMotionFunc ) Handles case where mouse enters the window with no buttons pressed. glutKeyboardFunc(myKeyboardFunc); Handles key presses and releases. Knows which key was pressed and mouse location. glutMainLoop() Runs forever waiting for an event. When one occurs, it is handled by the appropriate callback function.
- Slide 239
- Libraries to Include GL, for which the commands begin with GL; GLUT, the GL Utility Toolkit, opens windows, develops menus, and manages events. GLU, the GL Utility Library, which provides high level routines to handle complex mathematical and drawing operations. GLUI, the User Interface Library, which is completely integrated with the GLUT library. The GLUT functions must be available for GLUI to operate properly. GLUI provides sophisticated controls and menus to OpenGL applications.
- Slide 240
- A GL Program to Open a Window // appropriate #includes go here see Appendix 1 void main(int argc, char** argv) { glutInit(&argc, argv); // initialize the toolkit glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // set the display mode glutInitWindowSize(640,480); // set window size glutInitWindowPosition(100, 150); // set window upper left corner position on screen glutCreateWindow("my first attempt"); // open the screen window (Title: my first attempt) // continued next slide
- Slide 241
- Part 2 of Window Program // register the callback functions glutDisplayFunc(myDisplay); glutReshapeFunc(myReshape); glutMouseFunc(myMouse); glutKeyboardFunc(myKeyboard); myInit(); // additional initializations as necessary glutMainLoop(); // go into a perpetual loop } Terminate program by closing window(s) it is using.
- Slide 242
- What the Code Does glutInit (&argc, argv) initializes Open-GL Toolkit glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB) allocates a single display buffer and uses colors to draw glutInitWindowSize (640, 480) makes the window 640 pixels wide by 480 pixels high
- Slide 243
- What the Code Does (2) glutInitWindowPosition (100, 150) puts upper left window corner at position 100 pixels from left edge and 150 pixels down from top edge glutCreateWindow (my first attempt) opens and displays the window with the title my first attempt Remaining functions register callbacks
- Slide 244
- What the Code Does (3) The call-back functions you write are registered, and then the program enters an endless loop, waiting for events to occur. When an event occurs, GL calls the relevant handler function.
- Slide 245
- Effect of Program
- Slide 246
- Drawing Dots in OpenGL We start with a coordinate system based on the window just created: 0 to 679 in x and 0 to 479 in y. OpenGL drawing is based on vertices (corners). To draw an object in OpenGL, you pass it a list of vertices. The list starts with glBegin(arg); and ends with glEnd(); Arg determines what is drawn. glEnd() sends drawing data down the OpenGL pipeline.
- Slide 247
- Example glBegin (GL_POINTS); glVertex2i (100, 50); glVertex2i (100, 130); glVertex2i (150, 130); glEnd(); GL_POINTS is constant built-into Open- GL (also GL_LINES, GL_POLYGON, ) Complete code to draw the 3 dots is in Fig. 2.11.
- Slide 248
- Display for Dots
- Slide 249
- What Code Does: GL Function Construction
- Slide 250
- Example of Construction glVertex2i () takes integer values glVertex2d () takes floating point values OpenGL has its own data types to make graphics device-independent Use these types instead of standard ones
- Slide 251
- Open-GL Data Types suffixdata typeC/C++ typeOpenGL type name b8-bit integersigned charGLbyte s 16-bit integerShortGLshort i 32-bit integerint or longGLint, GLsizei f 32-bit floatFloatGLfloat, GLclampf d 64-bit floatDoubleGLdouble,GLclampd ub 8-bit unsigned number unsigned charGLubyte,GLboolean us 16-bit unsigned number unsigned shortGLushort ui 32-bit unsigned number unsigned int or unsigned long GLuint,Glenum,GLbitfield
- Slide 252
- Setting Drawing Colors in GL glColor3f(red, green, blue); // set drawing color glColor3f(1.0, 0.0, 0.0); // red glColor3f(0.0, 1.0, 0.0); // green glColor3f(0.0, 0.0, 1.0); // blue glColor3f(0.0, 0.0, 0.0); // black glColor3f(1.0, 1.0, 1.0); // bright white glColor3f(1.0, 1.0, 0.0); // bright yellow glColor3f(1.0, 0.0, 1.0); // magenta
- Slide 253
- Setting Background Color in GL glClearColor (red, green, blue, alpha); Sets background color. Alpha is degree of transparency; use 0.0 for now. glClear(GL_COLOR_BUFFER_BIT); clears window to background color
- Slide 254
- Setting Up a Coordinate System void myInit(void) { glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0, 640.0, 0, 480.0); } // sets up coordinate system for window from (0,0) to (679, 479)
- Slide 255
- Drawing Lines glBegin (GL_LINES); //draws one line glVertex2i (40, 100); // between 2 vertices glVertex2i (202, 96); glEnd (); glFlush(); If more than two vertices are specified between glBegin(GL_LINES) and glEnd() they are taken in pairs, and a separate line is drawn between each pair.
- Slide 256
- Line Attributes Color, thickness, stippling. glColor3f() sets color. glLineWidth(4.0) sets thickness. The default thickness is 1.0. a). thin lines b). thick lines c). stippled lines
- Slide 257
- Setting Line Parameters Polylines and Polygons: lists of vertices. Polygons are closed (right); polylines need not be closed (left).
- Slide 258
- Polyline/Polygon Drawing glBegin (GL_LINE_STRIP); // GL_LINE_LOOP to close polyline (make it a polygon) // glVertex2i () calls go here glEnd (); glFlush (); A GL_LINE_LOOP cannot be filled with color
- Slide 259
- Examples Drawing line graphs: connect each pair of (x, f(x)) values Must scale and shift
- Slide 260
- Examples (2) Drawing polyline from vertices in a file # polylines # vertices in first polyline Coordinates of vertices, x y, one pair per line Repeat last 2 lines as necessary File for dinosaur available from Web site Code to draw polylines/polygons in Fig. 2.24.
- Slide 261
- Examples (3)
- Slide 262
- Examples (4) Parameterizing Drawings: allows making them different sizes and aspect ratios Code for a parameterized house is in Fig. 2.27.
- Slide 263
- Examples (5)
- Slide 264
- Examples (6) Polyline Drawing Code to set up an array of vertices is in Fig. 2.29. Code to draw the polyline is in Fig. 2.30.
- Slide 265
- Relative Line Drawing Requires keeping track of current position on screen (CP). moveTo(x, y); set CP to (x, y) lineTo(x, y);draw a line from CP to (x, y), and then update CP to (x, y). Code is in Fig. 2.31. Caution! CP is a global variable, and therefore vulnerable to tampering from instructions at other points in your program.
- Slide 266
- Drawing Aligned Rectangles glRecti (GLint x 1, GLint y 1, GLint x 2, GLint y 2 ); // opposite corners; filled with current color; later rectangles are drawn on top of previous ones
- Slide 267
- Aspect Ratio of Aligned Rectangles Aspect ratio = width/height
- Slide 268
- Filling Polygons with Color Polygons must be convex: any line from one boundary to another lies inside the polygon; below, only D, E, F are convex
- Slide 269
- Filling Polygons with Color (2) glBegin (GL_POLYGON); //glVertex2f (); calls go here glEnd (); Polygon is filled with the current drawing color
- Slide 270
- Other Graphics Primitives GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN GL_QUADS, GL_QUAD_STRIP
- Slide 271
- Simple User Interaction with Mouse and Keyboard Register functions: glutMouseFunc (myMouse); glutKeyboardFunc (myKeyboard); Write the function(s) NOTE that any drawing you do when you use these functions must be done IN the mouse or keyboard function (or in a function called from within mouse or keyboard callback functions).
- Slide 272
- Example Mouse Function void myMouse(int button, int state, int x, int y); Button is one of GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_RIGHT_BUTTON. State is GLUT_UP or GLUT_DOWN. X and y are mouse position at the time of the event.
- Slide 273
- Example Mouse Function (2) The x value is the number of pixels from the left of the window. The y value is the number of pixels down from the top of the window. In order to see the effects of some activity of the mouse or keyboard, the mouse or keyboard handler must call either myDisplay() or glutPostRedisplay(). Code for an example myMouse() is in Fig. 2.40.
- Slide 274
- Polyline Control with Mouse Example use:
- Slide 275
- Code for Mouse-controlled Polyline
- Slide 276
- Using Mouse Motion Functions glutMotionFunc(myMovedMouse); // moved with button held down glutPassiveMotionFunc(myMovedMouse ); // moved with buttons up myMovedMouse(int x, int y); x and y are the position of the mouse when the event occurred. Code for drawing rubber rectangles using these functions is in Fig. 2.41.
- Slide 277
- Example Keyboard Function void myKeyboard(unsigned char theKey, int mouseX, int mouseY) { GLint x = mouseX; GLint y = screenHeight - mouseY; // flip y value switch(theKey) {case p: drawDot(x, y); break; // draw dot at mouse position case E: exit(-1); //terminate the program default: break; // do nothing }
- Slide 278
- Example Keyboard Function (2) Parameters to the function will always be (unsigned char key, int mouseX, int mouseY). The y coordinate needs to be flipped by subtracting it from screenHeight. Body is a switch with cases to handle active keys (key value is ASCII code). Remember to end each case with a break!
- Slide 279
- Using Menus Both GLUT and GLUI make menus available. GLUT menus are simple, and GLUI menus are more powerful. We will build a single menu that will allow the user to change the color of a triangle, which is undulating back and forth as the application proceeds.
- Slide 280
- GLUT Menu Callback Function Int glutCreateMenu(myMenu); returns menu ID void myMenu(int num); //handles choice num void glutAddMenuEntry(char* name, int value); // value used in myMenu switch to handle choice void glutAttachMenu(int button); // one of GLUT_RIGHT_BUTTON, GLUT_MIDDLE_BUTTON, or GLUT_LEFT_BUTTON Usually GLUT_RIGHT_BUTTON
- Slide 281
- GLUT subMenus Create a subMenu first, using menu commands, then add it to main menu. A submenu pops up when a main menu item is selected. glutAddSubMenu (char* name, int menuID); // menuID is the value returned by glutCreateMenu when the submenu was created Complete code for a GLUT Menu application is in Fig. 2.44. (No submenus are used.)
- Slide 282
- GLUI Interfaces and Menus
- Slide 283
- GLUI Interfaces An example program illustrating how to use GLUI interface options is available on book web site. Most of the work has been done for you; you may cut and paste from the example programs in the GLUI distribution.
- Slide 284
- UNIT-IV RENDERING
- Slide 285
- Polygon shading model Flat shading - compute lighting once and assign the color to the whole (mesh) polygon
- Slide 286
- Flat shading Only use one vertex normaland material property to compute the color for the polygon Benefit: fast to compute Used when: Polygon is small enough Light source is far away (why?) Eye is very far away (why?)
- Slide 287
- Mach Band Effect Flat shading suffers from mach band effect Mach band effect human eyes accentuate the discontinuity at the boundary Side view of a polygonal surface perceived intensity
- Slide 288
- Smooth shading Fix the mach band effect remove edge discontinuity Compute lighting for more points on each face Flat shading Smooth shading
- Slide 289
- Two popular methods: Gouraud shading (used by OpenGL) Phong shading (better specular highlight, not in OpenGL)
- Slide 290
- Gouraud Shading The smooth shading algorithm used in OpenGL glShadeModel(GL_SMOOTH) Lighting is calculated for each of the polygon vertices Colors are interpolated for interior pixels
- Slide 291
- Gouraud Shading Per-vertex lighting calculation Normal is needed for each vertex Per-vertex normal can be computed by averaging the adjust face normals n n1 n2 n3 n4 n = (n1 + n2 + n3 + n4) / 4.0
- Slide 292
- Gouraud Shading Compute vertex illumination (color) before the projection transformation Shade interior pixels: color interpolation (normals are not needed) C1 C2 C3 Ca = lerp(C1, C2)Cb = lerp(C1, C3) Lerp(Ca, Cb) for all scanlines * lerp: linear interpolation
- Slide 293
- Gouraud Shading Linear interpolation Interpolate triangle color: use y distance to interpolate the two end points in the scanline, and use x distance to interpolate interior pixel colors a b v1v2 x x = a / (a+b) * v1 + b/(a+b) * v2
- Slide 294
- Gouraud Shading Problem Lighting in the polygon interior can be inaccurate
- Slide 295
- Phong Shading Instead of interpolation, we calculate lighting for each pixel inside the polygon (per pixel lighting) Need normals for all the pixels not provided by user Phong shading algorithm interpolates the normals and compute lighting during rasterization (need to map the normal back to world or eye space though)
- Slide 296
- Phong Shading Normal interpolation Slow not supported by OpenGL and most graphics hardware n1 n2 n3 nb = lerp(n1, n3) na = lerp(n1, n2) lerp(na, nb)
- Slide 297
- UNIT-V FRACTALS
- Slide 298
- Fractals Fractals are geometric objects. Many real-world objects like ferns are shaped like fractals. Fractals are formed by iterations. Fractals are self-similar. In computer graphics, we use fractal functions to create complex objects.
- Slide 299
- Koch Fractals (Snowflakes) Iteration 0Iteration 1Iteration 2Iteration 3 Generator 1/3 1
- Slide 300
- Fractal Tree Iteration 1 Iteration 2 Iteration 3 Iteration 4 Iteration 5 Generator
- Slide 301
- Fractal Fern Generator Iteration 0 Iteration 1 Iteration 2 Iteration 3
- Slide 302
- Add Some Randomness The fractals weve produced so far seem to be very regular and artificial. To create some realism and variability, simply change the angles slightly sometimes based on a random number generator. For example, you can curve some of the ferns to one side. For example, you can also vary the lengths of the branches and the branching factor.
- Slide 303
- Terrain (Random Mid-point Displacement) Given the heights of two end-points, generate a height at the mid-point. Suppose that the two end-points are a and b. Suppose the height is in the y direction, such that the height at a is y(a), and the height at b is y(b). Then, the height at the mid-point will be: y mid = (y(a)+y(b))/2 + r, where r is the random offset This is how to generate the random offset r: r = sr g |b-a|, where s is a user-selected roughness factor, and r g is a Gaussian random variable with mean 0 and variance 1
- Slide 304
- How to generate a random number with Gaussian (or normal) probability distribution // given random numbers x1 and x2 with equal distribution from -1 to 1 // generate numbers y1 and y2 with normal distribution centered at 0.0 // and with standard deviation 1.0. void Gaussian(float &y1, float &y2) { float x1, x2, w; do { x1 = 2.0 * 0.001*(float)(rand()%1000) - 1.0; x2 = 2.0 * 0.001*(float)(rand()%1000) - 1.0; w = x1 * x1 + x2 * x2; } while ( w >= 1.0 ); w = sqrt( (-2.0 * log( w ) ) / w ); y1 = x1 * w; y2 = x2 * w; }
- Slide 305
- Procedural Terrain Example
- Slide 306
- Building a more realistic terrain Notice that in the real world, valleys and mountains have different shapes. If we have the same terrain-generation algorithm for both mountains and valleys, it will result in unrealistic, alien-looking landscapes. Therefore, use different parameters for valleys and mountains. Also, can manually create ridges, cliffs, and other geographical features, and then use fractals to create detail roughness.
- Slide 307
- Fractals Infinite detail at every point Self similarity between parts and overall features of the object Zoom into Euclidian shape Zoomed shape see more detail eventually smooths Zoom in on fractal See more detail Does not smooth Model Terrain, clouds water, trees, plants, feathers, fur, patterns General equation P1=F(P0), P2 = F(P1), P3=F(P2) P3=F(F(F(P0)))
- Slide 308
- Self similar fractals Parts are scaled down versions of the entire object use same scaling on subparts use different scaling factors for subparts Statistically self-similar Apply random variation to subparts Trees, shrubs, other vegetation
- Slide 309
- Fractal types Statistically self-affine random variations SxSySz terrain, water, clouds Invariant fractal sets Nonlinear transformations Self squaring fractals Julia-Fatou set Squaring function in complex space Mandelbrot set Squaring function in complex space Self-inverse fractals Inversion procedures
- Slide 310
- Julia-Fatou and Mandelbrot x=>x 2 +c x=a+bi Complex number Modulus Sqrt(a 2 +b 2 ) If modulus < 1 Squaring makes it go toward 0 If modulus > 1 Squaring falls towards infinity If modulus=1 Some fall to zero Some fall to infinity Some do neither Boundary between numbers which fall to zero and those which fall to infinity Julia-Fatou Set Foley/vanDam Computer Graphics-Principles and Practices, 2 nd edition Julia-Fatou
- Slide 311
- Julia Fatou and Mandelbrot cond Shape of the Julia-Fatou set based on c To get Mandelbrot set set of non-diverging points Correct method Compute the Julia sets for all possible c Color the points black when the set is connected and white when it is not connected Approximate method Foreach value of c, start with complex number 0=0+0i Apply to x=>x 2 +c Process a finite number of times (say 1000) If after the iterations is is outside a disk defined by modulus>100, color the points of c white, otherwise color it black. Foley/vanDam Computer Graphics-Principles and Practices, 2 nd edition
- Slide 312
- Constructing a deterministic self-similar fractal Initiator Given geometric shape Generator Pattern which replaces subparts of initiator Koch Curve Initiator generator First iteration
- Slide 313
- Fractal dimension D=fractal dimension Amount of variation in the structure Measure of roughness or fragmentation of the object Small d-less jagged Large d-more jagged Self similar objects ns d =1 (Some books write this as ns -d =1) s=scaling factor n number of subparts in subdivision d=ln(n)/ln(1/s) [d=ln(n)/ln(s) however s is the number of segments versus how much the main segment was reduced I.e. line divided into 3 segments. Instead of saying the line is 1/3, say instead there are 3 sements. Notice that 1/(1/3) = 3] If there are different scaling factors S k d =1 K=1 n
- Slide 314
- Figuring out scaling factors I prefer: ns -d =1 :d=ln(n)/ln(s) Dimension is a ratio of the (new size)/(old size) Divide line into n identical segments n=s Divide lines on square into small squares by dividing each line into n identical segments n=s 2 small squares Divide cube Get n=s 3 small cubes Kochs snowflake After division have 4 segments n=4 (new segments) s=3 (old segments) Fractal Dimension D=ln4/ln3 = 1.262 For your reference: Book method n=4 Number of new segments s=1/3 segments reduced by 1/3 d=ln4/ln(1/(1/3))
- Slide 315
- Sierpinski gasket Fractal Dimension Divide each side by 2 Makes 4 triangles We keep 3 Therefore n=3 Get 3 new triangles from 1 old triangle s=2 (2 new segments from one old segment) Fractal dimension D=ln(3)/ln(2) = 1.585
- Slide 316
- Cube Fractal Dimension Apply fractal algorithm Divide each side by 3 Now push out the middle face of each cube Now push out the center of the cube What is the fractal dimension? Well we have 20 cubes, where we used to have 1 n=20 We have divided each side by 3 s=3 Fractal dimension ln(20)/ln(3) = 2.727 Image from Angel book
- Slide 317
- Language Based Models of generating images Typical Alphabet {A,B,[,]} Rules A=> AA B=> A[B]AA[B] Starting Basis=B Generate words Represents sequence of segments in graph structure Branch with brackets Interesting, but I want a tree B A[B]AA[B] AA[A[B]AA[B]]AAAA[A[B]AA[B]] A AAAA B B A AAAA B AA B AAAAAAAA A B B
- Slide 318
- Language Based Models of generating images cond Modify Alphabet {A,B,[,],(,)} Rules A=> AA B=> A[B]AA(B) [] = left branch () = right branchStarting Basis=B Generate words Represents sequence of segments in graph structure Branch with brackets B A[B]AA(B) AA[A[B]AA(B)]AAAA(A[B]AA(B)) A AAAA B B A AAAA B AA B AAAAAAAA A B B
- Slide 319
- Language Based models have no inherent geometry Grammar based model requires Grammar Geometric interpretation Generating an object from the word is a separate process examples Branches on the tree drawn at upward angles Choose to draw segments of tree as successively smaller lengths The more it branches, the smaller the last branch is Draw flowers or leaves at terminal nodes A AAAA B AA B AAAAAAAA A B B
- Slide 320
- Grammar and Geometry Change branch size according to depth of graph Foley/vanDam Computer Graphics-Principles and Practices, 2 nd edition
- Slide 321
- Particle Systems System is defined by a collection of particles that evolve over time Particles have fluid-like properties Flowing, billowing, spattering, expanding, imploding, exploding Basic particle can be any shape Sphere, box, ellipsoid, etc Apply probabilistic rules to particles generate new particles Change attributes according to age What color is particle when detected? What shape is particle when detected? Transparancy over time? Particles die (disappear from system) Movement Deterministic or stochastic laws of motion Kinematically forces such as gravity
- Slide 322
- Particle Systems modeling Model Fire, fog, smoke, fireworks, trees, grass, waterfall, water spray. Grass Model clumps by setting up trajectory paths for particles Waterfall Particles fall from fixed elevation Deflected by obstacle as splash to ground Eg. drop, hit rock, finish in pool Drop, go to bottom of pool, float back up.
- Slide 323
- Physically based modeling Non-rigid object Rope, cloth, soft rubber ball, jello Describe behavior in terms of external and internal forces Approximate the object with network of point nodes connected by flexible connection Example springs with spring constant k Homogeneous object All ks equal Hookes Law F s =-k x x=displacement, F s = restoring force on spring Could also model with putty (doesnt spring back) Could model with elastic material Minimize strain energy k k k k
- Slide 324
- Turtle Graphics Turtle can F=Move forward a unit L=Turn left R=Turn right Stipulate turtle directions, and angle of turns Equilateral triangle Eg. angle =120 FRFRFR What if change angle to 60 degrees F=> FLFRRFLF Basis F Koch Curve (snowflake) Example taken from Angel book
- Slide 325
- Using turtle graphics for trees Use push and pop for side branches [] F=> F[RF]F[LF]F Angle =27 Note spaces ONLY for readability F[RF]F[LF]F [RF[RF]F[LF]F] F[RF]F[LF]F [LF[RF]F[LF]F] F[RF]F[LF]F

Recommended

UNIT I - 2D PRIMITIVES Line, Circle and Ellipse drawing fmcet.in/CSE/CS2401_uw.pdf2014-08-051 UNIT I - 2D PRIMITIVES Output primitives – Line, Circle and Ellipse drawing algorithms - Attributes of output primitives – Two dimensional Geometric transformation - Two dimensional viewing – Line, Polygon, Curve and ...Documents