1. 1 Lecture 4 Graphical primitives Rasterization: algorithmic approach Rasterization: geometric approach 2D discrete lines, triangles Discrete planes 3D discrete lines Meshes of triangles Graphical primitives in OpenGL

2. 2 Main elements of vector model Lines Polylines, polygons Curves Text

3. 3 Main elements of vector model Lines Polylines, polygons (simple, regular) Curves Text

4. 4 Main elements of vector model Lines Polylines, polygons (simple, regular) Curves Text

5. 5 Main elements of vector model Lines Polylines, polygons (simple, regular) Curves Text

6. 6 Main elements of vector model Lines Polylines, polygons (simple, regular) Curves are represented by their coordinates (x 1,y 1 ), (x 2,y 2 ), …, (x n,y n ) Coordinate system: origin, orientation of the axes, units

7. 7 Main elements of vector model Attributes: Color Thickness Line Style Fill Style Text Font/Style

8. 8 Main elements of vector model Attributes: Color Thickness Line Style Fill Style Text Font/Style

9. 9 Main elements of raster model Pixels/voxels pixel = picture element voxel = volume element Represented as a bitmap

10. 10 Main elements of mixed model Lines, curves, text are rasterized

11. 11 Main elements of mixed model Lines, curves, text are rasterized

12. 12 Approaches to rasterization: Algorithmic Approach Developing algorithms for the main geometrical primitives  Line segment Line segment  Circle Circle  Curve  Filled area

13. 13 Approaches: Algorithmic Approach. Deficiencies It is difficult to determine whether a pixel belongs to an object

14. 14 Approaches: Algorithmic Approach. Deficiencies It is difficult to determine the intersection of two objects

15. 15 Approaches: Algorithmic Approach. Deficiencies In some cases the quality of the picture is not satisfactory Algorithm

16. 16 Approaches: Algorithmic Approach. Deficiencies In some cases the quality of the picture is not satisfactory

17. 17 Approaches: Algorithmic Approach. Deficiencies In some cases the quality of the picture is not satisfactory

18. 18 Approaches: Geometric Approach. Objectives of the Geometric Approach:  Developing a relevant discrete counterpart of the analytical geometry (Discrete Analytical Geometry).  Developing efficient algorithms for generation of the basic primitives of the discrete analytical geometry. Advantages:  Makes up the deficiencies of the algorithmic approach.  Exact arithmetic.  Raising the computational efficiency of some algorithms.  Data compression.

19. 19 Approaches: Geometric Approach. Difficulties The intersection of two discrete lines may be 0, 1, or infinitely many points.

20. 20 Approaches: Geometric Approach. Difficulties The objects have thickness.

21. 21 Approaches: Geometric Approach. Difficulties In 3D the things become much more complex. The intersection of two planes is not a line. It may be even a disconnected set.

22. 22 Basic Definitions. Coordinate Systems, Pixels, Voxels Def. 2D Coordinate system Only the integer points are included. Pixels are unit squares centered about the integer points. Voxels are unit cubes centered about the integer points.

23. 23 Basic Definitions. Discrete Adjacency Def. 2D adjacency Let P1 and P2 be two pixels. They are 8-adjacent, if they share a vertex or an edge 4-adjacent, if they share an edge. Remark: 4-adjacent pixels are also 8-adjacent.

24. 24 Basic Definitions. Discrete Adjacency Def. 3D adjacency Let V1 and V2 be two voxels. They are 26-adjacent, if they share a vertex, an edge or a side. 18-adjacent, if they share an edge or a vertex. 6-adjacent, if they share a side. Remark: The 6-adjacent voxels are also 18- and 26-adjacent and the 18-adjacent voxels are also 26-adjacent.

25. 25 Basic Definitions. 2D Lines Def. 2D arithmetic line L(a,b, µ,w) is a set of pixels (x,y) satisfying the conditions 0  ax + by + µ < w w - arithmetical thickness µ - internal translation constant

26. 26 Basic Definitions. 2D Lines 0  ax + by + µ < w 0  3x - 5y < 5 x | y ------- -------- 0 | 0 8 | 4 1 | 0 9 | 5 2 | 1 10 | 6 3 | 1 11 | 6 4 | 2 12 | 7 5 | 3 13 | 7 6 | 3 14 | 8 7 | 4

27. 27 Basic Definitions. 2D Lines 0  3x - 5y < 5 Let P = 3x - 5y x | y | P ---------- 0 | 0 | 0 8 | 4 | 4 1 | 0 | 3 9 | 5 | 2 2 | 1 | 1 10 | 6 | 0 3 | 1 | 4 11 | 6 | 3 4 | 2 | 2 12 | 7 | 1 5 | 3 | 0 13 | 7 | 4 6 | 3 | 3 14 | 8 | 2 7 | 4 | 1

28. 28 Basic Definitions. Types of 2D Lines If w<max(|a|, |b|): disconnected If w=max(|a|, |b|): naïve If w=|a|+|b|: standard If w>|a|+|b|: thick

29. 29 Basic Definitions. Types of 2D Lines If w<max(|a|, |b|): disconnected If w=max(|a|, |b|): naïve If w=|a|+|b|: standard If w>|a|+|b|: thick

30. 30 Basic Definitions. Types of 2D Lines If w<max(|a|, |b|): disconnected If w=max(|a|, |b|): naïve If w=|a|+|b|: standard If w>|a|+|b|: thick

31. 31 Basic Definitions. Types of 2D Lines If w<max(|a|, |b|): disconnected If w=max(|a|, |b|): naïve If w=|a|+|b|: standard If w>|a|+|b|: thick

32. 32 Basic Definitions. Tunnels in 2D Lines A line L (a,b,µ,w) has an k-tunnel, if there exist two k- adjacent pixels A and B, such that ax A +by A +µ<0 and ax B +by B +µ  w

33. 33 Basic Definitions. Bresenham Line Bresenham line corresponding to the Euclidean line ax + by + c = 0 is 0  ax + by + c+[w/2] < w, where w=max(|a|, |b|)

34. 34 Discrete Triangles Problems: Def.: Let A, B, C be given. Border: union of the Bresenham lines AB, BC, CA Interior: All the integer points, belonging to the Euclidean triangle ABC, which do not belong to the border.

35. 35 Discrete Planes Def. Discrete plane P(a,b,c,µ,w) is a set of voxels (x,y,z) satisfying the conditions 0  ax + by + cz + c < w w - arithmetical thickness µ - internal translation constant Naïve plane: w=max(|a|, |b|, |c|} Standard plane: w=|a|+|b|+|c|

36. 36 Discrete Planes Def. Discrete plane P(a,b,c,µ,w) is a set of voxels (x,y,z) satisfying the conditions 0  ax + by + cz + c < w w - arithmetical thickness µ - internal translation constant Naïve plane: w=max(|a|, |b|, |c|} Standard plane: w=|a|+|b|+|c|

37. 37 Discrete Planes Def. A plane P has a k-tunnel (n=6,18,26) if there exist two k-adjacent voxels A and B such that ax A + by A + cz A + µ <0 and ax B + by B + cz B + µ  w Tunnel-free is equivalent to 26-tunnel-free.

38. 38 Functionality Def. A plane P is functional on a coordinate plane, e.g. Oxy, if for any voxel (x,y) from Oxy there is exactly one voxel belonging to P. The plane Oxy is called functional coordinate plane for P.

39. 39 3D Lines Def. A 3D discrete line is defined as an intersection of two discrete planes. 0  - cx + az + µ < w 0  - cy + bz + µ’ < w’

40. 40 Graphical Primitives in OpenGL  OpenGL uses primitives to draw all the vector primitives that we studied: points, lines, polygons, rectangles, etc.  2D and 3D  Remark: For 3D primitives we have to call projection function, e.g. glOrtho as in the example of drawing triangle.  All functions for drawing primitives start with glBegin( PRIMITIVE_NAME ) and end with glEnd().

41. 41 Graphical Primitives in OpenGL  Example: The following fragment draws one 3D point. glBegin( GL_POINTS ); glVertex3f( 0.2, 0.4, 0.3 ); glEnd();  Example: The following fragment draws four 3D point. glBegin( GL_POINTS ); glVertex3f( 0.1, 0.1, 0 ); glVertex3f( 0.1, 0.5, 0 ); glVertex3f( 0.5, 0.5, 0 ); glVertex3f( 0.5, 0.1, 0 ); glEnd();

42. 42 Graphical Primitives in OpenGL  Example: The following fragment draws a square. glColor3f( 1.0, 0.0, 0.0 ); glBegin( GL_POLYGON ); glVertex3f( 0.1, 0.1, 0 ); glVertex3f( 0.1, 0.5, 0 ); glVertex3f( 0.5, 0.5, 0 ); glVertex3f( 0.5, 0.1, 0 ); glEnd();

43. 43 Graphical Primitives in OpenGL  Z-coordinate is zero. We can skip it. glColor3f( 1.0, 0.0, 0.0 ); glBegin( GL_POLYGON ); glVertex2f( 0.1, 0.1 ); glVertex2f( 0.1, 0.5 ); glVertex2f( 0.5, 0.5 ); glVertex2f( 0.5, 0.1 ); glEnd();

44. 44 Graphical Primitives in OpenGL  Remark: the order of the vertices is important.  The program that we considered will draw the following window: My first OpenGL program

45. 45 Graphical Primitives in OpenGL  Remark: the order of the vertices is important.  The program: glColor3f( 1.0, 0.0, 0.0 ); glBegin( GL_POLYGON ); glVertex2f( 0.1, 0.5 ); glVertex2f( 0.1, 0.1 ); glVertex2f( 0.5, 0.5 ); glVertex2f( 0.5, 0.1 ); glEnd(); My first OpenGL program

46. 46 List of the Primitives

47. 47 GL_POINTS glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_POINTS); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

48. 48 GL_POINTS glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_POINTS); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

49. 49 GL_LINES: connects two points to form a line. Odd number of vertices: last ignored glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_LINES); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

50. 50 GL_LINE_STRIP: draws lines without lifting the pen glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_LINE_STRIP); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

51. 51 GL_LINE_LOOP do the same as GL_LINE_STRIP and connect the first and last points glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_LINE_LOOP); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

52. 52 GL_TRIANGLES take vertices in groups of three and draw triangles. If the number of Vertices is not divisible by 3, those vertices at the end are ignored. What will this program fragment draw? glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_TRIANGLES); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

53. 53 GL_TRIANGLE_STRIP also does this with the exception that every vertex after the first three forms a connected triangles( i.e., v0, v1, v2, then v2, v1 and v3, then v2, v3 and v4). glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_TRIANGLE_STRIP); glVertex3f( 0.1, 0.2, 0.0 ); glVertex3f( 0.1, 0.5, 0.0 ); glColor3f ( 1.0, 0.0, 0.0 ); glVertex3f( 0.5, 0.5, 0.0 ); glVertex3f( 0.5, 0.2, 0.0 ); glEnd();

54. 54 GL_TRIANGLE_FAN forms triangles that share the common first vertex. glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_TRIANGLE_FAN); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.9, 0.5, 0 ); glVertex3f( 0.5, 0.2, 0 ); glEnd();

55. 55 GL_QUADS takes vertices in-groups of four to draw four-side polygons. If the number of points is not divisible by 4, the last a few points are ignored. glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_QUADS); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.1, 0.5, 0 ); glVertex3f( 0.5,0.5,0); glVertex3f( 0.5,0.2, 0 ); glColor3f( 0.0, 1.0, 0.0 ); glVertex3f( 0.6,0.2, 0 ); glVertex3f( 0.6,0.6, 0 ); glVertex3f( 0.9,0.6, 0 ); glVertex3f( 0.9,0.2, 0 ); glEnd();

56. 56 GL_QUADS takes vertices in-groups of four to draw four-side polygons. If the number of points is not divisible by 4, the last a few points are ignored. GL_QUAD_STRIP draws quads(four sided polygons) using vertices v0, v1, v2, v3 then v4, v5, v6, v7.

57. 57 GL_POLYGON draws a polygon with the specified vertices glColor3f( 0.0, 0.0, 1.0 ); glBegin(GL_POLYGON); glVertex3f( 0.1, 0.2, 0 ); glVertex3f( 0.1, 0.9, 0 ); glVertex3f( 0.9, 0.9, 0 ); glVertex3f( 0.9, 0.2, 0 ); glEnd();

58. 58

59. 59 Approaches: Algorithmic Approach. Line Segment

60. 60 Approaches: Algorithmic Approach. Line Segment

61. 61 Approaches: Algorithmic Approach. Line Segment Back

62. 62 Discrete Circles Approaches: y=sqrt(r 2 – x 2 ) – bad quality of the image x=r.cos(φ), y=r.sin(φ) – slow

63. 63 Discrete Circles Symmetry: The formula y=sqrt(r 2 – x 2 ) is used for the second octant. The symmetry of the circle is explored

64. 64 Discrete Circles

65. 65 Discrete Circles Back

66. 66 Approaches: Algorithmic Approach. Deficiencies for i:= 1 to 200 do Circle (x, y, i); Back