### Media/Text Files/Other/Mathematics of Three-Dimensional Manipulations

The Mathematics of Three-Dimensional Manipulations and Transformations. ---------------------------------------------------------------------------- Edition 1.2, by Trip V. Reece, June 1992. e-mail: tvreece@caticsuf.csufresno.edu cis: Trip V. Reece 70620,2371 Permission is given to copy and distribute without alteration. Table of Contents ----------------- I. Mapping 3d onto 2d A. Skrinkage of X,Y dimensions B. Vanishing Point @ C. Aspect Ratio II. Translation and Scaling A. The easy way B. Via Matrices III. Rotation A. Rotating a 2d coordinate B. Rotation around another point C. Rotating a 3d coordinate D. The Matrix Solution IV. Matrices Unveiled A. The Affine Transformation Generalized B. Choices, Choices V. Z-Buffering A. Why? B. How? VI. Techniques A. Bresenham's Drawing algorithm I. Mapping Three-Dimensional coordinates onto a Two-Dimensional Plane Although the title for this entry appears stultifying, indeed formidable, it is little other than identifying the relationships between distance and perspective. The most important concept in 3d display is the apparent shrinkage of objects as they recede. The other concept to keep in mind is the idea of a vanishing point. It would be easier to simply transcribe the formula here, but to properly implement a 3-dimensional system, a thorough knowledge and understanding of EACH aspect of the system is VITAL. Otherwise, how can you track down slow operations and optimize efficiently? The goal of this mapping function is to be able to pass it the three-dimensional coordinates and have it return the two dimensional coordinates for the monitor screen. To understand how the mapping works, try to visualize a transparent, flat, rigid, plastic sheet with dots marked on it in a regular pattern, like so: . . . . . . . . . . . . . . . . . . . . Now, imagine each of these dots to be 3cm from the dot above/below or to the left or right of it. Imagine now, if you will, another, perfectly identical sheet of plastic exactly 3cm from the first, parallel to the first and further away from you than the first. Now, imagining how it would look, you would notice that the X and Y dimensions are contracted with greater intensity the further away a sheet of plastic is from you. The marks on the plastic appear to be "pulled in" to the point directly in front of your eyeball, contracted >towards< that point. The first concept, that of diminishing size with distance is given by the relationship: Size (= Original Size / Distance Note: The (= symbol is my ascii approximation for an alpha, the symbol for >proportional to<. This, however, does not account for the vanishing point, the second concept used here. To get another perspective on how the vanishing point works, find a flat floor with a regular pattern of parallel lines on it (they're easy to find) and stand vertical in front of it. Now, using a single eye, look towards the horizon, and with two rulers, align their edges along with the parallel lines on the floor. Hold the rulers in front of your face, also vertical, and each should point at a slightly different angle from the other. Now, look at the rulers that you have lined up. If you follow their edges to the point where they would have intersected if they were long enough, you (should)/will find that they meet at a point directly in front of your eye. This point is called the vanishing point, and is used by artists to construct realistic perspective drawings. Typically, to achieve a more realistic rendering, a cut-off distance is used to make points that are more than a certain distance away disappear. To avoid the magnifying effect that would be evident when rendering an object that is of a distance less than one all objects closer than 1 unit of distance away are cut off. The reason an object so close would become magnified is because the relationship Size (= original_size / distance, would make 1/distance larger than 1, therefore multiplying the original size by a value greater than 1. We can now reveal the first mapping function, which although incomplete, provides a clear understanding of its function. ( Equation 1-1 ) Precondition: Z is greater than or equal to 1. Value: Shrinkage = ( 1 - scale / Z ) New X = Old_X - Shrinkage * Old_X New Y = Old_Y - Shrinkage * Old_Y Now, we have declared Shrinkage to be the value of one minus the value of scale divided by the distance plus one. Ignore scale for now, the value Z is the Z coordinate of the three-dimensional point. If you multiplied out the expanded form of Shrinkage into the value of New X you would get: New X = Old_X - Old_X * ( 1 - scale/Z ) which is the same as: New X = Old_X - Old_X + Old_X * scale / Z which is the same as: New X = Old_X / Z * scale Why do we calculate the value of Shrinkage at all? Because it is used in both the New X and New Y caluclations, and also because the picture this would produce does not look "right." Let's first reason out the meaning of the "scale" value. During practice, it looks really weird for an object to recede so far into the distance that it nearly touches the vanishing point. Let's simply say that scale's value is most apparent when it equals 1. The theory doesn't yet explain why the value of scale is needed, so let's examin it a bit more carefully. For a realistic image, the vanishing point is usually from one fourth the total height to one third of the total height down from the top of the image, and usually in the middle of the left/right length. I can't explain why this looks "right," it may look completely wrong to some, but I've heard no complaints yet. Now, to revise the formulas: ( Equation 1-2 ) PreCondition: Z is greater or equal to 1. Shrinkage = ( 1 - scale / Z ) New X = Old_X - Shrinkage * Old_X New Y = Old_Y - Shrinkage * ( Old_Y - EyeLevel ) A few assumptions are made here, first: that the origin is located in the center of the screen, and that EyeLevel is a positive number. EyeLevel tells us how HIGH UP from the origin the vanishing point should be. Typically, if the vertical resolution of the screen is MaxY then the maximum positive coordinate would be MaxY / 2 and if this value were divided by 3 then you would have EyeLevel = MaxY / 6. What the subtraction of MaxY does to the incoming Y coordinates is to translate everything UP. Yes, it sounds backwards, but when you subtract inside the parantheses, it becomes addition outisde of the parantheses, so it really is ADDED, but added BEFORE it is mapped onto the 2-d plane. Now, why isn't the X coordinate similarly translated? Because: in a typical picture, the vanishing point is in the center of the horizontal direction, which is where the origin is in this implementation. If the origin were anywhere else on the screen, it >would< have to be translated to the center of the screen. This should now help to explain how the value of "scale" works. In practice, a large value of scale tends to make the horizon much closer. In fact, this is exactly what scale does for us. It narrows the depth of field, in a sense. If you increase the value of scale from 1 to a large value, objects that previously stretched back towards the vanishing point now seem to be much thinner, and hence more realistic. The value of scale is dependant upon the horizontal resolution of the screen. I have found that a setting scale equal to the horizontal resolution provides reliable results. Fiddle around with this value, but after a while, you will want the scale to remain constant in your program. One other nagging little problem with all of this is the dreaded aspect ratio. Depending on the graphics mode you are in, if the maximum X resolution is not the same as the maximum Y resolution then you must, that is >MUST< scale either the final X or final Y coordinate by this ratio. You will want to compute this ratio at the beginning of your program so as to avoid any unnecessary divides. This is how to do it: Ratio = MaxYresolution / MaxXresolution Now, this ratio is usually, 1.333333... for modes such as 640x480, or 800x600, or 1024x768, but may change as video displays improve and older modes, such as 320x200, are used. To convert your "final" X and Y coordinates into something that you can plot on the monitor you must multiply the X coordinate by this ratio before you plot the point. Alternatively, you can computer the reciprocal of the ratio, and multiply the "final" Y value by this "inverse ratio" to scale it that way. But always remember to avoid division wherever possible, multiplication of non-integers is much faster than division by anything, especially zero. :-) That's it for mapping! Feel free to use equation 1-2 in any of your programs! II. Translation and Scaling in Three Dimensions Starting with a definition: Translating a three-dimensional coordinate means to simply add a value to each of the X, Y, and Z coordinates. Scaling a three-dimensional coordinate means to simply multiply each of the X, Y, and Z coordinates by a value. This is irrelevant in dealing with single points, but when this is performed to a grouping of points, such as those in a cube, you can translate each coordinate by the same values for X Y and Z, to move the cube about in three dimensions. Scaling the coordinates definitely provides for an interesting (i.e. entertaining) effect. Objects will grow or shirnk depending on the value it is scaled by. Scaling a single axis can elongate or shrink an object along that axis. Typically, scaling occurs infrequently in a 3d modelling system, whereas translations are the basis of animation and interactive displays. Note: Translation provides for movement in ONLY >along< the X, Y, and Z axes. Rotation is another matter entirely. III. Rotation Since 3d geometry is really no different from 2d geometry, except with regards to the complexity of visualizing the math, rotations in 3d are similarly rooted in 2d geometry. Warning: If you haven't had trigonometry experience, you will not understand this- read a book on it. Now, everything in digital computers is usually expressed in integers or in rounded off floating-point numbers. Coordinates of objects in either 2 or 3 dimensions is usually done in Cartesian, or Rectangular coordinates. This means we have distinct values for X, Y (and/or Z) that are unique to that point. In dealing with rectangular coordinates, when we want to rotate a point about the origin (0,0) in two-dimensions, we would convert the X,Y coordinate into an (R,Theta) polar coordinate, add the angle we wish to rotate the point to Theta, and then convert (R,New_Theta) back into rectangular. This is honestly one of the quickest methods to rotate a single point about the origin. The following identities are useful, indeed >necessary< to compute the rotated X and Y values. ___________ R = \/ X^2 + Y^2 or: R = ( X^2 + Y^2 ) ^ 0.5 X = R * Cos (Theta) Y = R * Sin (Theta) Tangent ( Y / X ) = Theta Theta = ArcTangent ( Y / X ) Sine ( Y / R ) = Theta Theta = ArcSin ( Y / R ) Cosine ( X / R ) = Theta Theta = ArcCos ( X / R ) The value of R remains constant during the rotation. We first compute the value of R then. R = sqrt ( Old_X * Old_X + Old_Y * Old_Y ) Now, we must compute the OLD value of theta. Theta = ArcTan ( Old_Y / Old_X ) Now, we must compute the new values of X and Y. New_X = R * Cos ( Theta + RotateAngle ) New_Y = R * Sin ( Theta + RotateAngle ) Ahh, but wait! This will not work all the time! Why not? Because when Old_X is negative, the value of Theta will be the value of the reference angle, NOT the angle from the origin! A simple fix is to use the following code instead: New_X = R * Cos ( Theta + RotateAngle ) If Old_X < 0 then New_X = New_X + Pi -or- if you are working in degrees: If Old_X < 0 then New_X = New_X + 180 and not forgetting to include: New_Y = R * Sin ( Theta + RotateAngle ) The conversion between radians (it has pi in it) into degrees is to multiply the radian measure by ( 180 / Pi ) and to convert degrees into radians, you multiply the degree measue by ( Pi / 180 ). What this means is that 2*Pi radians equals 360 degrees, 180 degrees equals Pi radians, and 0 degrees equals 0 radians. When you have a negative Old_X value, the value of Theta returned by ArcTangent ( Y / X ) is the angle measured from the left handed side of the x axis, this angle is the angle measured DOWN from the left side, not from the right side of the x axis. Adding Pi radians (180 degrees) gives us the angle from the right side-- a positive value of Y will cause the ArcTangent function to return a negative angle. This negative angle is the angle UP from the left side of the x axis; adding 180 degrees gives us the angle from the right side. When X >and< Y are negative, the ArcTangent function gives us a positive angle, the angle DOWN from the left side of the x axis. Adding 180 degrees clearly gives us the angle from the right side. Remember now, that angles are measured CounterClockwise from the right side of the x axis to the angle Theta. If we did not know the original coordinates of X and Y, we would not be able to determine the correct value of Theta because the ArcTangent function only returns values between -90 degrees and +90 degrees (or -Pi/2 radians to +Pi/2 radians.) Suppose we didn't want to rotate the point about the origin, but about another point on the X,Y plane? Simplicity itself! Look at the rotation as a rotation about the origin, only the origin is displaced by the coordinates of the point about which you are really rotating (re-read that sentence if necessary.) Call that second point the origin, and you're set. If you make the point you want to rotate relative to the origin the same as it is relative to the second point, then translate it back, you've got it. So, if we call the point about which we want to rotate Rot_X, Rot_Y then we are left with: Old_X2 = Old_X1 - Rot_X Old_Y2 = Old_Y1 - Rot_Y Now, perform the rotation with Old_X2 and Old_Y2 in place of Old_X and Old_Y respectively. Then, after you finish that, translate it back with: New_X2 = New_X1 + Rot_X New_Y2 = New_Y1 + Rot_Y Now, if that isn't enough obfuscation, I shall write out the complete rotation with all variables in their proper place: R = ( (Old_X - Rot_X)^2 + (Old_Y - Rot_Y)^2 ) ^ 0.5 Theta = ArcTangent ( Y / X ) If (Old_X - Rot_X) < 0 then Theta = Theta + Pi New_X = R * Cos (Theta + RotateAngle) + Rot_X New_Y = R * Sin (Theta + RotateAngle) + Rot_Y To re-iterate this, RotateAngle is that angle in RADIANS COUNTERCLOCKWISE that you wish to rotate the original coordinate, (Old_X,Old_Y), about the point (Rot_X,Rot_Y). To implement this in a 3-dimensional frame, simply define what axis about which to wish to rotate a point (or group of points, as in an object) and in place of X and Y put the two axes that are left (NOT the axis about which you are rotating) in their place. Now, the Rot_X and Rot_Y coordinates are the coordinates of the LINE that you are rotating the point(s) about. If you wanted to rotate an object about the origin, leave Rot_x and Rot_Y zero. If you wish to rotate the object about it's center but along the Z axis, calculate the average of all X values and all Y values for that object and substitute those in for Rot_X and Rot_Y. Remember that you can also rotate in the X or Y directions also! If you wished to rotate an object about the X axis, around the origin for the X axis you would make Rot_X, Rot_Y equal to the Z and Y coordinates of the X axis: ZERO. You would then put the Z and Y dimension coordinates in place of the values of Old_X and Old_Y (they're just variable identifiers, mathematically, you may rotate about any axis.) If you mix up the order of Z and Y, (Frankly, I'm nt even sure about the "correct" order.) then the only side-effect will be that your rotations are reversed in direction. It's all a matter of perspective, >you< decide what direction you wish to look head-on for each of the axes. In my examples, I'm assuming the Z axis goes into the screen and X and Y are left/right and top/bottom respectively. --Matrices How is this solved with matrices? It is not as easy to rotate about another point with matrices, but rotating about a single axis is relatively straightforward. Consider the matrix*matrix problem below: Rotation about X axis: | 1 0 0 0 | | 1 | | A | | 0 cT sT 0 | * | x | = | B | | 0 -sT -cT 0 | | y | | C | | 0 0 0 1 | | z | | D | [ cT = Cos(Theta), sT = Sin(Theta) ] If you go ahead with the matrix multiplication (I'll write it all out for those who are rusty this first time,) then you get a result of: A = 1*1 + 0*x + 0*y + 0*z = 1 B = 0*1 + cos(Theta)*x + sin(Theta)*y + 0*z = x*cos(Theta) + y*sin(Theta) C = 0*1 + -sin(Theta)*x + -cos(Theta)*y + 0*z = x*-sin(Theta) - y*cos(Theta) D = 0*1 + 0*x + 0*y + 1*z = z A = 1, B= x*cos(Theta)+y*sin(Theta), C= -x*sin(Theta)-y*cos(Theta), D= z New_X = B New_Y = C New_Z = D This is the rotation of a point (x,y,z) about the X axis, for Theta degrees. I'd guess this is a correct rotation... But the value of C seems to be incorrect. However, I will stick to non-matrix calculations to eliminate all those unnecessary ???*0 + ???*0 + ???*1 operations. [ I consent that these transforms make no sense to me. ] Rotation about Y axis: | cT 0 -sT 0 | | 1 | | A | | 0 1 0 0 | * | x | = | B | | -sT 0 cT 0 | | y | | C | | 0 0 0 1 | | z | | D | In this case: A = 1*cos(Theta) + 0*x + y*-sin(Theta) + 0*z = cos(Theta) - y*sin(Theta) B = 0*1 + 1*x + 0*y + 0*z = x C = 1*-sin(Theta) + 0*x + y*cos(Theta) + 0*z = -sin(Theta) + y*cos(Theta) D = 0*1 + 0*x + 0*y + 1*z = z Again, this really looks pretty wrong. Perhaps I'm not multiplying matrices correctly, or maybe the matrices are set up wrongly. However, if it works- use it. Rotation about Z axis: | cT sT 0 0 | | 1 | | A | | -sT cT 0 0 | * | x | = | B | | 0 0 1 0 | | y | | C | | 0 0 0 1 | | z | | D | In this case: A = 1*cos(Theta) + x*sin(Theta) + 0*y + 0*z = cos(Theta) + x*sin(Theta) B = -sin(Theta)*1 + x*cos(Theta) + 0*y + 0*z = -sin(Theta) + x*cos(Theta) C = 0*1 + 0*x + 1*y + 0*z = y D = 0*1 + 0*x + 0*y + 1*z = z Now, this may make some sense. Rotating about the z axis should only affect the x and y coordinates. Hmm, in this case A and B >must< hold the new X and Y coordinates, since C contains an unchanged value of y. Well, that's all about rotation with matrices that I'm prepared to be flamed for. [ I honestly don't understand how this works, if it does at all. ] IV. Matrices Unveiled This section is postponed until I can get some accurate information about the matrices for rotation and other affine transformations. V. Z-Buffering - The how's and the why's. Okay. translation and rotation may be all fine and dandy, but suppose I want to display my teapot that I've got encoded in a very nice compact data structure, but it looks transparent. In fact, it looks like a wireframe, which it is! -How to go about Z-Buffering- First, get the memory. Wherever possible, grab memory. You will need for this exercise: enough memory for 3 times the video resolution in pixels, for example: 320x200 = 64000. You will need 320x200x3 = 192000 bytes for this, unless you choose to perform some in-memory compression, an adivsable technique! This assumes you are using 8-bit color, i.e. 256 color. First, reserve one byte for each pixel on the screen as part of a "virtual" screen. This byte will store the color for that pixel once the 3d mapping and depth checking is complete. Initialize this array with the background color of your choice. Next, reserve two bytes (using the type integer, for example) for each pixel on the virtual screen in another array (yes this spans two segments of memory or more.) These two bytes store the distance of the pixel in the range from 0 .. 65535. This is the Z-Buffer itself. In actuality, it shouldn't be called a Z buffer in a perspective rendering modeller. It is properly a Distance-Buffer, but in an orthographic environment, the depth is the same as the Z coordinate, so the name stuck. Oh well. Initialize this array of distances with the value of 65535, or whatever your yon/hither values dictate. It is a good idea to set a maximum distance on the objects you render, as well as a minimum distance- this prevents unnecessary calculations that would end up in an object rendered that only appeared as three small pixels not worthy of being called a polygon, or an impossibly huge triangle (for example) that covers up everything else on the screen. Use your judgement. To draw a single frame now: Scroll through your list of objects that are in visible sight. Calculate the distance of each vertex from your eyeball using the pythagorean distance formula: ______________________ Distance = \/ X^2 + Y^2 + Z^2 or: Distance = ( X^2 + Y^2 + Z^2 ) ^ 0.5 Now, calculate the coordinates of the mapped point on the 2d plane for this vertex. (This should account for the vanishing point, as well as perspective.) Now, compare the value of this distance with the value of the distance contained in the array of distances at the pixel location you just found the 2d mapped coordinates of. If this vertex is of a less distance then replace the byte in the array of color with the color of this pixel, and store the calculated distance into the "Z-Buffer" array of distances at the location where you found it to lie on the 2d plane. The gist of this all is to compare the distance of a point with the distance found in the array, if the distance already in the array is less than the distance of the pixel we are checking, then throw out that new pixel. A pixel closer to you will "cover up" a pixel that is farther away. To Z-Buffer a polygon, the vertices of the polygon must be projected onto the Z-Buffer plane, and checked for overlapping. Even if the vertices aren't visible, there may be points on the polygon that >are< visible due to a "hole" in another polygon that just happens to be blocking the rest of the polygon we are rendering. Instead of calculating the distance to each pixel of the polygon (entailing far too many squareds and square root operations to be feasible on most 80x86's) a form of interpolation may be used provided the four vertices and their distances; and upon the condition that the polygon is perfectly flat. Of course Z-Buffering can also apply to non-polygonal shapes, however, it radically increases rendering time to use non-polygons. After all the shapes/polygons have been rendered onto the virtual screen, the screen of visible colors must be copied into the video area. This can be quickened by storing the color array in video memory to begin with, and page in the new screens as they are available. Be sure not to have the video screen showing that you are currently Z-Buffering! That would give away the secret! :-) Another improvement to make that is simplified when Z-Buffering is shading polygons. Simply calculate the angle between the polygon normal (the perpendicular to the polygon's surface) and the light source (a "global" value) and take the cosine of this angle to get the intensity of the light reflected off the polygon. Be sure to multiply the value of the cosine by the maximum allowable intensity, since cosine returns values ranging from -1,...+1. Negative values either should be negated to get the positive value, or it could signify a hidden surface, i.e. a surface that faces away from the viewer. VI. Techniques and Algorithms Bresenham's Line Drawing Algorithm -The importance of this algorithm is evident when it is implemented with ONLY integer math. This can drastically improve calculation times. This function takes in the X and Y coordinates of the endpoints of the line to be drawn. To make it more versatille, it also will accept the color of the points it is to plot. The whole trick behind how this works is based on the mathematical fact that multiplication is really only repeated addition, and division is really only repeated subtraction. There are two cases for the line drawing algorithm, 1: a line with a slope >= 1, and 2: a line with a slope < 1. Since slope is (delta Y)/(delta X) this means that the algorithm is dependent upon the fact that deltaY or delta X is the larger of the two. Let's consider case 2, where delta X exceeds delta Y. The algorithm "follows" along the X-axis, incrementing the x value of the line it plots by one each time, and it calculates the value of y on each run through the x increment loop. A variable which could be called "Cycle" is first initialized to the value of one half of delta X. This variable, Cycle will be incremented by the value of delta Y and then checked against the value of delta X. If cycle is greater than delta X then the value of the y-coordinate to be plotted is upped by one (assuming the line's slope is positive) and the value of Cycle has the value of delta X subtracted from it. The value of the x coordinate of the point where the algorithm plots the new point each run through the loop is incremented by one, unconditionally. Now, another run through the loop will give us: increment Cycle by delta Y, check to see if it's greater than delta X, (If YES: Cycle=cycle-delta X and Y_plot=Y_plot+1, else If NO: then don't change Y_plot.) Now, X_plot=X_plot+1. Perhaps an table of the values of Cycle, X_plot, & Y_plot as the loop is executed will better explain what is happening. The values passed to the algorithm are called x1, y1, x2, y2. delta Y = y2 - y1 = 4 ( arbitrary points chosen for clarity ) delta X = x2 - x1 = 9 Cycle | X_Plot | Y_Plot -----------+------------+------------ 4 | x1 | y1 4+4= 8 | x1+1 | y1 8+4=12-9=3 | x1+2 | y1+1 ( y1 is incremented because cycle 3+4= 7 | x1+3 | y1+1 overflowed delta X ) 7+4=11-9=2 | x1+4 | y1+2 ( <-- overflowed again! ) 2+4= 6 | x1+5 | y1+2 6+4=10-9=1 | x1+6 | y1+3 ( <-- another overflow ) 1+4= 5 | x1+7 | y1+3 5+4=9-9= 0 | x1+8 | y1+4 ( cycle must never = delta x ) 0+4= 4 | x1+9 | y1+4 Here the loop ends because delta X = 9 and x1+9 equals delta X. Actually, this is leaving out an important detail: if y2 is below y1 then instead of adding a positive 1 for each overflow of Cycle, a 1 must be subtracted. This can be done easily by setting a variable called Increment equal to positive one or negative one at the beginning of the routine. In the case of delta Y being larger than delta X, follow the same procedure as above, but the loop will follow the line vertically, so replace delta X with delta Y and vice versa. It can be shown that the pattern that Cycle takes on needs not be calculated beyond a certain point. As soon as Cycle regains the value it had to begin with (delta X divided by two, rounded down) it will follow the same pattern again and again. I suspect that Cycle will always begin to repeat at or before delta_X number of positions down the list. It is possible that the algorithm could beoptimized even further- calculate the first delta_X values for Cycle, perform a check and identify each position where cycle >>decreases<< (i.e. it has overflowed and Y_Plot must be incremented)- place a one at each point where Y_Plot must be incremented, and then follow along >this< array and increment Y_Plot (or X_Plot as the case may be) where a one occurs. And if you have the Megs and Megs of memory available, you could precalculate each of these arrays for every possible combination of delta Y and delta X... Maybe that's going a bit far now- :-). Why use the Bresenham line drawing algorithm? It's blazingly fast. Consider the work needed in dividing half a zillion line slope calculations, in real-time. This routine only requires addition, subtraction, and a check. The intel processors have been optimized to all hell for wicked speed at addition/subtraction/comparisons, whereas division will ALWAYS be slow slow slow... ... More algorithms to come! ... Note: I intend this article to be a growing text to help decipher the cryptic world of 3d, as I learn more I will add to this list. I also know that I, like most people of the younger generation, am prone to errors. Tell me about them! I want to learn more about this, can't find or afford most of the books on this subject, so anything you can tell me will be appreciated! and included if it makes any sort of sense! -Trip V. Reece Any comments, suggestions, errata reports please email me. e-mail: tvreece@caticsuf.csufresno.edu

Title | Mathematics of Three-Dimensional Manipulations |
---|---|

Type | Text |

Size | 30.259 kB |

Date Added | 2008-07-15 |

Views | 5747 |

Category | Text Files |

Placement |