 |
 |
|
A wheel with 8 spokes is turning at a rate of 1 revolution per second. What does the wheel appear to do when it is rendered at 10 frames/sec. without any anti-aliasing measures ? |
How many B&W line pairs can you draw on a display with 1200x1200 square pixels: (a) vertical lines in the horizontal direction ? (b) diagonal lines between opposite corners ? Pixel Patterns Kell Factor |
Filtered Transparency:
Assume that in the frame buffer there is a pixel (Fr, Fg, Fb, Fa),
and we want to place a new pixel with opacity a
in front of it (Nr, Ng, Nb, Na):
We can achieve the desired result with: ( a*Nr
+ kt*Fr, a*Ng
+ kt*Fg, a*Nb
+ kt*Fb, a*Na
+ kt*Fa );
this corrsponds to placing a filter of opacity a
in front of an already rendered scene.
(if a=1 the New pixel dominates).
For this blending function to work, the transparent polygons have to
be rendered after (in front of) the opaque objects.
For multiple filter polygons, the effect is calculated recursively
back-to-front.
Interpolated Transparency:
In a different situation, we might want to form a composite image from m
candidate images
(e.g. m different surfaces sharing parts of one pixel; or in Image-based Rendering: interpolating between m different views).
In this case, the compositing function might look like: ( sum(Nri)/m,
sum(Ngi)/m, sum(Nbi)/m,
sum(Nai)/m, )
OpenGL provides many different blending functions to take care of many
commonly occuring situations.
Example: Scull
and Brain
Source: http://graphics.stanford.edu/projects/volume/
Why is it called aliasing
? ==> Strong connection to signal processing!
But here we deal with a spatial/frequency domain (rather than the time/frequency domain).
To properly resolve a high-frequency signal (or spatial structure) in a sampled environment,
we must take at least TWO samples for the highest-frequency periods of the signal. This is called the Nyquist frequency limit.
Problems arise, if our signal frequency exceeds this Nyquist limit.
If our sampling frequency is too low, the corresponding humps in the frequency domain move closer together and start to overlap!
Now frequencies in the different humps start to mix and can no longer be separated (even with the most perfect filter!).
Thus some high frequency components get mis-interpreted as much lower frequencies;
-- they take on a different "personality" or become an a alias.
{The figures used here are from P. Heckbert's MS Thesis: http://www-2.cs.cmu.edu/~ph/texfund/texfund.pdf }
What does a computer graphics person have to know ?
This occurs with all sampling techniques!
Rendering techniques that are particularly affected:
-- Ray-casting, ray-tracing: -- Because we are sampling
the scene on a pixel basis.
-- Texture-mapping: -- Because we use a discretely
sampled texture map.
==> Fight it ! -- "NO
JAGGIES!"
-- Techniques to overcome it are
called anti-aliasing.
If we cannot increase sampling density,
then we must lower the spatial frequencies by lowpass filtering the
input -- BEFORE we sample the scene!
This cuts off the high frequency components that could cause trouble by overlapping with lower "good" frequencies.
In the context of ray-tracing we shoot multiple rays per pixel ==> Leads to "Distribution Ray Tracing".
This not only lets us gracefully filter out the higher, bothersome spatial frequencies,
it also allows us to overcome temporal aliasing problems caused by fast moving objects (e.g.. spoked wheel in warm-up question).
By taking several snapshots at different times in between subsequent frames and combining them,
we can produce "motion blur" and generate the appearance of a fast smooth motion.
If the
frequency content of the texture pattern is close to screen resolution,
then there are no higher spatial frequencies present than what the pixel sampling can handle.
But if the texture is of much higher resolution, then there is a serious problem!
Fortunately there are filtering techniques that can fix that problem -- simple oversampling will do.
There are more advanced techniques using elliptical filtering that can give even better results.
There is another issue with sampled texture patterns:
In a perspective projection, it is not good enough to determine the
texture coordinates
of the many pixels of a texture-mapped polygon simply by linear interpolation, since the
perspective projection to 2D is a non-linear operation.
If we simply linearly interpolate the texture coordinates along the edges of our polygons
(or the triangles or trapezoids that they may be cut up into), the
texture pattern will appear warped.
We need to properly foreshorten the texture coordinates with the perspective transform, so that the result will appear realistic.
By analyzing the differences of their relative positions in the two
images, one can extract 3D depth information.
Thus groups of pixels in both images can be annotated with a distance
from the camera that took them.
This basic approach can be extended to many different pictures taken from
many different camera locations.
The depth annotation establishes an implicit 3D database of the geometry
of the model object or scene.
Pixels at different depths then get shifted by different amounts.
To produce a new image from a new camera location, one selects
images taken from nearby locations
and suitably shifts or "shears" the pixel positions according to their
depth and the difference in camera locations.
The information from the various nearby images is then combined in
a weighted manner,
where closer camera positions, or the cameras that see the surface of interest under a
steeper angle, are given more weight.
With additional clever processing, information missing in one image
(e.g., because it is hidden behind a telephone pole)
can be obtained from another image taken from a different angle,
or can even be procedurally generated by extending nearby texture patterns.
Example 1: Stereo
from a single source:
A depth-annotated image of a 3D object, rendered from two different
camera positions.
Example 2: Interpolating an
image from neighboring positions:
To Learn More: UNC Image-Based Rendering
Future Graduate Courses: CS 283, CS 294-?
As an approximation, one captures many renderings from many locations
(often lying on a regular array of positions and directions),
ideally, all around the given model object, but sometimes just from
one dominant side.
This information is then captured in a 4D sampled function (2D
array of locations, with 2D sub arrays of directions).
One practical solution is to organize and index this information (about
all possible light rays in all possible directions)
by defining the rays by their intercept coordinates (s,t) and (u,v)
of two points lying on two parallel planes.
The technique is applicable to both synthetic and real worlds, i.e.
objects they may be rendered or scanned.
Creating a light field from a set of images corresponds to inserting
2D slices into the 4D light field representation.
Once a light field has been created, new views may be constructed by
extracting 2D slices in appropriate directions,
i.e., by collecting the proper rays that form the desired image, or a few close-by images that can be interpolated.
If we are primarily concerned with the 3D geometry of the object or scene to be modeled, then we may use a 3D scanner
Such a device takes an "image" by
sampling the scene like a ray-casting machine,
but which also returns for each pixel the distance from the scanner.
This collection of 3D points is then converted into a geometrical model,
by connecting neighboring sample dots
(or a subset thereof) into 3D
meshes.
Color information can be associated with all vertices, or overlaid
as a texture taken from a visual image of the scene.
This all requires quite a bit of work, but it results in a traditional
B-rep model that can be rendered with classical techniques.
Challenges: To combine the point clouds taken from many different
directions into one properly registered data set,
and to reduce the meshes to just the "right number" of vertices, and to
clean up the "holes" in the resulting B-rep.
Example: Happy Buddha.
If we want to acquire internal, inaccessible geometry, e.g., of
a brain, or a fetus, or of the bone structure of a living creature, we
may use a computer tomography technique (MRI or ultra sound) that
returns a 3D raster of data points with some variable, acquired value
such as density, or water content. To make this data visible in a
reasonable manner, we then need some different rendering techniques from
what we have discussed in this course.
One apprach is to define some threshold on the measured variable (e.g.
denisty), and declare all 3D raster points with values above this
threshold as "inside" and all others as "outside." We can then generate a surface between the
inside and the outside points (interpolate
surface between sample points), for instance with an algorithm called Marching
Cubes.
This reconstructed surface can then be rendered with any of the rendering techniques that we have discussed.
INSTRUCTIONS ( Read carefully ! )
DO NOT OPEN UNTIL TOLD TO DO SO !
TIME LIMIT: 170 minutes. Maximum number of points: ____.
CLEAN DESKS: No books; no calculators
or other electronic devices; only writing implements
and TWO double-sided sheet
of size 8.5 by 11 inches of your own personal notes.
NO QUESTIONS ! ( They are typically unnecessary and disturb the
other students.)
If any question on the exam appears unclear to you, write down what the
difficulty is
and what assumptions you made to try to solve the problem the way you
understood it.
DO ALL WORK TO BE GRADED ON THESE SHEETS OR THEIR BACKFACES.
NO PEEKING; NO COLLABORATION OF ANY KIND!
I HAVE UNDERSTOOD THESE RULES:
Your
Signature:___________________________________
Think through the topics covered in this course.
Practice by working through some questions of the posted: Old CS 184 Exams
Prepare one additional sheet of notes to be used during the exam.
