graphics in 3d 1 by dr. hany elsalamony. with a solid understanding of the 2d math involved in this...

Graphics in 3D

1By Dr. HANY ELSALAMONY

With a solid understanding of the 2D math involved in this world, we are ready to venture into the world of 3D graphics.

The mathematics in a 3D world is an elegant extension of its 2D counterparts. Most concepts in 3D are developed from 2D by simply adding a third (z-) axis. Positions of objects are now described as (x, y, z) triplets instead of just (x, y) pairs.

Transformation equations are defined against three axes, not two.

2By Dr. HANY ELSALAMONY

But 3D graphics is a lot more than just drawing simple objects.

This section begins our question into visual realism: how can we simulate a 3D world in the computer and then compute images that render out like photographs?

By Dr. HANY ELSALAMONY 3

3D Productions are built up on three basic building blocks: modeling, rendering and animation.

The first two blocks-modeling and rendering-form the basis for this section. Together they determine the final displayed image.


3D Modeling

The first and most critical pillar of 3D graphics is modeling.

Modeling is the process of creating a 3D model in the computer.


The representation can be of various kinds. Quantitative models use equations to

represent and describe system behavior; organizational models use hierarchies to represent classification schemes.

A CG model refers to the geometrical representation of the entity. The purpose of the model is to allow people to visualize the structure of the entity being modeled.


When we model an object on the computer, we tell the computer about the shape, spatial layout, and connectivity of components that compose the object.

In the last lecture, we saw examples of how to create simple 2D models such as polygons and circles. In this lecture, we expand our horizons to a 3D world.

We will learn the process of viewing three-dimensional worlds and how to create, compose, and transform models in this world.


In this lecture, you will learn the following concepts:

Representation of the 3D system 3D math: vectors, matrices and

transformations

Creating models of:1.primitive shapes2.generic shapes

Viewing the 3D world Creating hierarchical models using

transformationsBy Dr. HANY ELSALAMONY 8

The 3D System In order to represent a 3D world, we need

to extend our coordinate system into three dimensions. Every point in the 3D world is located using three coordinate values instead of 2.

In order to define points with three coordinates, we define a third axis, typically called the z-axis. The z-axis is perpendicular to the x- and y- axis (i.e., it is at 90 degrees with respect to the two axes - also referred to as orthogonal).


All three axes meet at the origin defined as (0,0,0) as shown in figure. This is our 3D world coordinate system.


Points in 3D space are identified by a triplet of (x, y, z) values. The vector notation for this triplet is represented as:

The Open GL function to define a vertex point (x, y, z) in 3D is


In the following code, we define the points of the circle in the x-z plane (not the x-y plane).


3D Math: Vectors

A vector in 3D has the same semantics as in 2D - it can be thought of as a displacement from one point to another.

Consider two points P(1,- 1,l) and Q(3,-2,2) as shown in Figure. The displacement from P to Q is the vector


calculated by subtracting the coordinates of the points individually.

Any point PI with coordinates (x, y, z) corresponds to the vector v p 1, with its head at (x, y, z) and tail at (0,o) as shown in. That is, a 3D point is essentially a vector with its tail at the origin (0,0,0).


A unit vector is a vector that has a magnitude of one unit. For example, the unit vector along the z-axis is:


vectors in 3D Space

3D Modeling

CG scenes depict objects of all different kinds: people, trees, flowers, fire, etc.

Each one has radically different characteristics in terms of look and feel.

So it should come as no surprise that there is no one standard modeling methodology-each object begs a different treatment to do full justice to the model.


The most popular and commonly used method to model objects is to use small polygons to approximate the surface.

This method is popular due to:1.Ease of use.2.Speed of display3.the abundance of algorithms to deal

efficiently with polygon based models.


The Polygon

Let us look into more detail on polygons and how they are used to model more complex shapes.

A polygon is much like a cutout piece of cardboard.

Drawing a polygon is like playing a game of connect the dots: each dot is a vertex defining the polygon.


You need at least three vertices to define the polygon. Each line of the polygon is called an edge.

More formally, a polygon can be defined as a set of non-crossing straight lines joining coplanar points to enclose a single convex area.


A single area means that the enclosed area should not be divided.

The convex requirement means that given any two points within the polygon, you must be able to draw a straight line connecting these two points without going outside the area of the polygon


The polygons are required to be flat (that is, to be defined in a single plane).


Legal and Illegal Polygons

Hence, most graphics software use triangles and triangle strips to define polygonal based models.

However, this approach is not essential, as we shall see when we define our primitive objects.


Front- Facing and Back- Facing Polygons Just as a piece of cardboard has two

sides to it, a polygon has two sides or faces, referred to as the front-face and the back-face.

In CG, the order in which you specify the vertices of the polygon defines the orientation of the polygon.


when polygon vertices are defined in counterclockwise order on the screen the polygon is said to be front facing.

If you reverse the order of the

vertices, the polygon is back facing: that is its back face is facing the viewer.

If you turn a front facing polygon around, it will become back-facing.



Front- and back-facing Polygons

Back-face Culling

In real life, you cannot see all sides of a solid object. You see only the sides facing you! The sides facing away from you are obstructed from view.

To achieve this effect in CG, we make use of the front- and back-facing polygon concept. (And you were wondering why it was such a big deal!) The front- facing polygons are facing towards the camera and drawn into the scene.


The back-facing polygons are facing away from the camera and hence are culled from the scene. This process is known as back-face culling.

In the following figure, we show our pyramid and a sphere with all the sides visible, and then the same objects with the back faces culled from the scene, thereby generating a much more realistic image.



Back-face culling applied to a) pyramid, and b) sphere

To instruct OpenGL to discard back facing

polygons, use the command


When you run the program, you will see only the pyramid's front facing polygon. The back facing polygons are culled out--exactly what we wanted.

The reader is encouraged to try rotating the pyramid to see how back-face culling affects the final output.

By definition, as the pyramid turns around, the faces that were back-facing become front-facing (and vice versa).


Normal vectors can also be used to determine the orientation of polygons.

There is a one-to-one correspondence between the direction of the normal vector and the order in which the polygon vertices are defined.

If the normal vector of the polygon points in the direction of the camera, then the polygon is front facing, else it is back facing, as shown in figure.



Normal define the face of a polygon

Polygon mesh

Polygons have limited usefulness by themselves. The real power of polygons comes when they are used together in a mesh structure to make a more complex shape.

A polygon mesh (referred to as strips in open GL) is a collection of polygons such that each edge is shared by at most two polygons, as shown in figure.



Polygon mesh - approximating a circle

Since the triangles actually share their edges, we can think of the polygons forming a solid model defined by the triangular mesh.

(Ideally, triangles share edges, so the shared edges need not be redefined. For the sake of simplicity, we will let the triangles be defined individually.

Since they are all connected, they effectively define a mesh).


In fact, the outer hull of all models can be approximated by a polygonal mesh.

The representation of models with just this mesh displayed is referred to as wireframe representation.


Almost all designers start off by constructing wireframe representations of their models. Once they are satisfied with the hull of their model, they will then add lighting and material properties to render the models as a solid.

Let us look into how we can define primitive shapes using polygonal meshes.


3D Modeling Primitive Shapes Primitive shapes have a well-defined

mathematical formula that defines the shape of their outer hull.

Objects such as spheres, cubes, cones, etc. fall into this category.

These surfaces are also called implicit surfaces, since they are defined by an implicit formula.


Polygon meshes can be easily used to construct these shapes.

For the sake of convenience, most graphics software provide these shapes as primitive objects in their own right.

Let us look into some of these shapes in more detail.


Cube

The cube model (or box) is one of the most common shapes occurring in nature.

If we know the center about which the cube is based, then the length, height and depth completely define the cube as shown.


A cube defined by its three dimensions

Sphere

Spheres are the most symmetrical shape occurring in nature. For this reason, they are also the simplest to define.

To completely define a sphere, we need to define its radius, R, and the location of its center, O. If we center the sphere around our world origin, then any point P on the surface of the sphere can be defined by the angles θ and φ that it subtends at the origin as shown in figure



Approximating a sphere

If we incrementally advance angle θ from -90 to 90 degrees (-PI to PI radians) and φ from 0 to 360 degrees (0 to 2PI radians), we can define a set of vertex points approximating the surface of the sphere.

These vertex points can then be connected into a polygonal mesh to define the outer hull of the sphere.

The closer the intervals, the more accurate our model will be.


Cone

A cone can be thought of as having a circular base and a conical surface.

The base of the cone can be defined as a circle on the x-z plane: the math is similar to the way we constructed a circle.

We approximate the conical surface of the cone by drawing a set of lines connecting the tip of the cone (a point along the y-axis) to the vertices along the circular base.



Approximating a cone

The teapot was first modeled in 1975 using curve and surface modeling techniques. It has now become an icon for CG and hence is included in the primitives list. The call to generate a teapot in glut is



The famous Utah teapot

3D Modeling: Generic Shapes For any kind of generic shape, we can

always define a polygonal mesh with sufficient complexity to approximate its hull.

The reader is encouraged to imagine some generic 3D models and to try modeling them using polygons, as discussed.

It's not an easy task! How would you go about defining the 3D vertices to model a tree, for example?


Defining the vertices of the polygons and/or curves in a 3D space can be a nerve racking experience if you don't have the necessary mathematical tools.

Defining the vertices of the polygons and/or curves in a 3D space can be a nerve racking experience if you don't have the necessary mathematical tools.


Just like image information, model information can be saved in files.

For this lecture, we make use of model files to illustrate how generic objects can be modeled using polygons.


Model files

What is stored in a model file? If the model is a primitive, then the key parameters defining the primitive are saved.

If it is a generic model, then information about the (polygonal or cubic) primitives used to construct it are saved.


There are many formats in which the model information can be stored. Maya stores models in its own propriety format.

For this course, we shall use an open format called the VRML format. You can find many VRML models free over the Internet. Indeed, we encourage you to go ahead and download VRML model files yourself to experiment with.


VRML files store polygonal information as follows:

For each model in the file:

First, all the coordinates of the vertex points are listed as (x, y, z) triplets. Then the index of each vertex in this list is used to specify the vertices forming the polygonal faces of the model, with a -1 as the delimiter.


For example, to draw two triangles that form the faces of a unit square (following figure), the vertices would be listed as:

and the indices forming the faces would be listed as:


Normal vectors to each polygon/vertex are defined in a similar manner.


Triangular faces forming a square

First the normal vectors are defined, and then the indices are defined determining the face to which the normal applies.

Of course, we can actually calculate the normal vectors for each polygon, by computing the cross product of its defining vectors!

VRML models also contain material information, which we shall not look into.


For example, we read in the VRML file robot. wrl: a model of an Android model.

The model itself consists of different shapes forming the head, legs, hands, etc of the Android. The code to read in the model is simple. We will define:

MAXSHAPES determines the maximum number of shapes that will be read from the file.


MCOORDS indicates the maximum number of coordinates that each shape may have.

We define the MAXSHAPES that we can read in to be 25 and the maximum coordinate data per shape as 3000:


The array to hold the coordinate data is defined as

This structure will hold the coordinate data for up to 3000 vertices (9000/3)per shape and up to 25 shapes.


The normal data is similarly defined, although we will not use it in this lecture. The index array holds information for up to 3000 triangular faces and up to 25 shapes.


For each shape, both arrays hold the three coordinates/indices of each vertex/polygon in a linear one-dimensional manner.

We maintain a count of the number of polygons defined by each shape


In the main code, we read in an android model as follows:

We can draw the models in many different ways. The simplest way is to draw the triangular faces one by one using the glVertex command.


An easier way to define the vertices is by making a call to the OpenGl function

Using this function, the display code can be modified to be



An Android, read from a VRML model

The figure before shows the output of the code.


graphics in 3d 1 by dr. hany elsalamony. with a solid understanding of the 2d math involved in this...

Documents

d models

d graphics

hany elsalamonyby

hany elsalamonybut

hany elsalamonywith

hany elsalamonyall

hany elsalamonypoints

hany elsalamonywhen