Vision Systems

Image Acquisition
The first stage of any vision system is the image acquisition stage.

After the image has been obtained, various methods of processing can be applied to the image to perform the many different vision tasks required today.

However, if the image has not been acquired satisfactorily then the intended tasks may not be achievable, even with the aid of some form of image enhancement

2D Image Input

The basic two-dimensional image is a monochrome (greyscale) image which has been digitised.

Describe image as a two-dimensional light intensity function f(x,y) where x and y are spatial coordinates and the value of f at any point (x, y) is proportional to the brightness or grey value of the image at that point.

A digitised image is one where

• spatial and greyscale values have been made discrete.
• intensity measured across a regularly spaced grid in x and y directions
• intensities sampled to 8 bits (256 values)

For computational purposes, we may think of a digital image as a two-dimensional array where x and y index an image point. Each element in the array is called a pixel (picture element)

2D Input Devices
TV Camera or Vidicon Tube

A first choice for a two-dimensional image input device may be a television camera -- output is a video signal:

• Image focused onto a photoconductive target.
• Target scanned line by line horizontally by an electron beam
• Electric current produces as the beam passes over target.
• Current proportional to the intensity of light at each point.
• Tap current to give a video signal.

This form of device has several disadvantages.

Click to Read More

PNG - The Definitive Guide

By Greg Roelofs

Part I, Using PNG
Part I is intended for designers, web site owners, casual image creators, and web surfers--anyone who wants a quick start on using PNG images in a variety of applications. Such users may need only a brief overview of PNG features, but they want to know what applications support the format and to what extent, how to invoke PNG-specific features within the applications, and how to work around certain bugs or incompatibilities in the applications. Of course, a book like this cannot possibly stay current, particularly not when it comes to software, but every effort has been made to ensure that the information is accurate as of the day this is written (mid-April 1999).

• Chapter 1, "An Introduction to PNG", covers some basic concepts of computer images and file formats, explains how PNG fits in and where using it is most appropriate (and most inappropriate!), and ends with an in-depth look at an image-editing application with particularly good PNG support.
• Chapter 2, "Applications: WWW Browsers and Servers", looks at PNG support in web browsers and servers and shows how to use the HTML OBJECT tag and server-side content negotiation to serve PNG images to browsers capable of viewing them.
• Chapter 3, "Applications: Image Viewers", lists more than 75 applications capable of viewing PNG images, with support for a dozen operating systems. Viewers that are additionally capable of converting to or from other image formats are so noted.
• Chapter 4, "Applications: Image Editors", looks at PNG support in five of the most popular image editors, showing how to invoke such features as gamma correction and alpha transparency, and indicating some of the problems unwary users may encounter.
• Chapter 5, "Applications: Image Converters", covers five conversion applications in detail, including one specifically designed to optimize PNG images and another designed to test PNG images for conformance to the specification. In addition, the chapter lists another 16 dedicated image converters beyond those in Chapter 3, "Applications: Image Viewers".
• Chapter 6, "Applications: VRML Browsers and Other 3D Apps", looks at PNG as a required texture format of the VRML 97 specification and investigates the level of conformance of seven browsers. It also lists a dozen PNG-supporting applications designed for the editing or rendering of 3D scenes.

Part II, The Design of PNG
Part II looks at the PNG format from an historical and technical perspective, detailing its structure and the rationale behind its design. Part II is intended for more technical readers who want to understand PNG to its core.

• Chapter 7, "History of the Portable Network Graphics Format", looks at the events leading up to the creation of PNG, some of the design decisions that went into the format, how it has fared in the subsequent years, and what to expect for the future.
• Chapter 8, "PNG Basics", covers the basic ``chunk'' structure of PNG files and compares PNG's level of support for various fundamental image types against that of other image formats.
• Chapter 9, "Compression and Filtering", delves into the heart of PNG's compression engine, provides the results of some real-world compression tests, and offers a number of tips for improving compression to both users and programmers of the format.
• Chapter 10, "Gamma Correction and Precision Color", discusses one of the least understood but most important features of PNG, its support for platform-independent image display. That is, in order for an image to appear the same way on different computer systems or even different print media, it is necessary for both the user and the program to understand and support gamma and color correction.
• Chapter 11, "PNG Options and Extensions", details the optional features supported by PNG, including text annotations, timestamps, background colors, and other ancillary information.
• Chapter 12, "Multiple-Image Network Graphics", is a brief look at PNG's multi-image cousin, MNG, which supports animations, slide shows, and even highly efficient storage of some types of single images.

Part III, Programming with PNG
Part III covers three working, libpng-based demo programs in detail, and lists a number of other toolkits that offer PNG support for various programming languages and platforms. It is intended for programmers who wish to add PNG support to their applications.

• Chapter 13, "Reading PNG Images", is a detailed tutorial on how to write a basic PNG-reading display program in C using the official PNG reference library. The application is divided into a generic PNG back end and platform-specific front ends, of which two are provided (for 32-bit Windows and the X Window System).
• Chapter 14, "Reading PNG Images Progressively", inverts the logic of the previous chapter's demo program, simulating the design of a web browser's display-as-you-go PNG code. Progressive display of interlaced, transparent PNG images over a background image is supported.
• Chapter 15, "Writing PNG Images", shows how to create a basic PNG-writing program. The supplied code compiles into a simple command-line program under both Windows and Unix, and it includes support for interlacing, gamma correction, alpha transparency, and text annotations.
• Chapter 16, "Other Libraries and Concluding Remarks", lists a number of alternative libraries and toolkits, both free and commercial, including ones for C, C++, JavaTM, Pascal, tcl/tk, Python, and Visual Basic. The chapter ends with a look back at what parts of the PNG design process worked and what didn't, and also a look forward at what lies ahead.
  The References section lists technical references and resources for further information, both printed and electronic.
• The Glossary defines a number of acronyms and technical terms used throughout the book.

Click to Read More

Compute!'s First Book of Atari Graphics

The Basics Of Atari Graphics

Tom R. Halfhill

If you are new to the Atari and have acquired a bit of familiarity with BASIC, but have not yet taken the plunge into graphics, this article will introduce you to the fundamentals.

For some reason, many people are intimidated by the programming steps required to create computer graphics. Probably this is because creating computer graphics is not as easy as it looks. The typical buyer of a personal computer is dazzled in the store by all the fantastic arcade games and impressive graphics demos with which the sales people are armed. It all looks so simple. Then the buyer eagerly unpacks the computer at home and quickly discovers that even crude pictures cannot be created without screenfuls of cryptic programming that seemingly have more in common with Sanskrit than English.

But there is hope. It's not really that hard--honest. Nobody is promising that you'll be able to duplicate Star Raidersor PacManany time soon, but the basics of computer graphics are quite easy to grasp for anyone who has some knowledge of BASIC programming. You don't need to be a math wizard, either. The most valuable attributes are a willingness to learn and to experiment. And, of course, to be creative.

Choosing A Graphics Mode
Atari graphics are particularly challenging to learn, mainly because the Atari computers have extremely versatile graphics. Luckily, Atari made it easier for us by including many special keywords in Atari BASIC that are dedicated to graphics. The first step, then, is to learn those keywords. And by the way, if you don't already have your Atari BASIC Reference Manualhandy, take a second to grab it. This book and the Manualshould help to explain each other.

The most basic of the keywords is the GRAPHICS command. This tells the computer which graphics mode you want, which in turn determines how the screen will look. The format is GRAPHICS (aexp), where (aexp) is any arithmetic expression that results in a positive integer (in other words, not a negative number or a fraction). For example, GRAPHICS 6 is a valid command which tells the computer you want graphics mode six. GRAPHICS 3 + 3 or GRAPHICS 3*2 would do the same thing.

Depending upon how old your Atari is, the GRAPHICS command gives you access to either nine or twelve different graphics modes. The reason for the difference is that earlier Ataris (generally, those shipped before late 1981) came with a TV controller chip called the CTIA. Later Ataris have a GTIA chip instead. The chips are fully compatible--programs written on CTIA Ataris will run on GTIA machines and vice versa--but the GTIA adds three new graphics modes. Users with CTIA chips can have their computers upgraded if they wish. (See "Atari Video Graphics And The New GTIA" in Chapter 6.)

Click to Read More

Atari Graphics & Arcade Game Design

By Jeffrey Stanton with Dan Pinal

Atari computers are wonderful graphics machines capable of extraordinary visual effects. Unfortunately, few of these can be implemented directly from Atari BASIC without a thorough knowledge of Machine language and the architecture of the machine. Those who understand the techniques and have mastered them are mostly too busy writing programs to share their knowledge.

This book will allow you to enter the world of Atari graphics in which your most imaginative ideas can be animated. The various chapters will present a comprehensive course in both Atari graphics and high-speed arcade animation techniques. While at least half of the book requires the ability to program in Assembly language, we were careful to bigin the book with the simplest graphics concepts 'in Atari BASIC. The book alms to increase the novice programmer's skill. It assumes no prior knowledge of either Atari graphics or Assembly language. Since we know that many of our readers will be young teenagers, we made every attempt to include BASIC program examples, some with Machine language subroutines, in most of the chapters. We felt that concepts like custom display lists, color indirection, scrolling, character set animation, and player-missile graphics can be learned by beginners, but we didn't neglect the advanced programmer either. We cover the most advanced topics possible on a Machine language level. We discuss vertical blank and display list interrupts, kernals, bit-mapped graphics, sound, scrolling, and player-missile graphics, and use these techniques to develop four complete Assembly language games.

The only requirements for this book are an inquisitive mind, perseverance, and a good Assembler. Although prior Assembly language programming experience isn't necessary, you won't be able to write code without an Assembler.

We will attempt to explain the ideas in this book through a combination of text, drawings, flow charts, and working code. The concepts in this book may seem easy at times, and somewhat difficult at other times. The Atari is a complex machine with many idiosyncrasies. The hardware sometimes makes game design relatively easy, yet the concept of an interrupt-driven machine with its timing problems can make advanced programming frustrating. Out advice is to read the book in stages and try the examples. Learn how they work.

Click to Read More

Vector Math for 3D Computer Graphics

An Interactive Tutorial

Third Revision, July 2003

This is a tutorial on vector algebra and matrix algebra from the viewpoint of computer graphics. It covers most vector and matrix topics needed to read college-level computer graphics text books. Most graphics texts cover these subjects in an appendix, but it is often too short.

The purpose of these notes is to expand on the mathematical appendix included with most graphics books, not to teach the material in the main text of those books. Many important subjects are not treated here. Such topics are 2D and 3D transformations, transformations between coordinate systems, and projections. Just when the math gets interesting and useful is where these notes stop.

Although primarily aimed at university computer science students, this tutorial is useful to any programmer interested in 3D computer graphics or 3D computer game programming. In spite of their appealing blood-and-gore covers, mass trade books on game programming require the same understanding of vectors and matrices as college text books (and usually defer these topics to the same skimpy mathematical appendix).

This tutorial is useful for more than computer graphics. Vectors and matrices are used in all scientific and engineering fields, and any other field that uses computers (are there any that don't?) In many fields, the vocabulary used for vectors and matrices does not match that used in computer graphics. But the ideas are the same, and reading these notes will take only a slight mental adjustment.

These notes assume that you have studied plane geometry and trigonometry sometime in the past. Notions such as point, line, plane, and angle should be familiar to you. Other notions such as sine, cosine, determinant, real number, and the common trig identities should at least be a distant memory.

Click to Read More/Download

Computer Graphics Primer

By Mitchell Waite

This book is about one of the most exciting uses of the new home computer products—computer graphics—the ability to create complex drawings, plans, maps, and schematics on the screen of an ordinary black-and-white or color television. It is divided into three chapters. Chapter 1, “Perspectives,” presents what the entirely new field of home computer graphics is all about, explains how it got started, and illustrates some of the exciting applications for low-cost graphics displays. Chapter 2, “Basic Concepts,” introduces the general hardware and software concepts behind computer graphics and continues by presenting a profile of the numerous products on the market today. A section on graphics accessories is also included.

Chapter 3, the meat of the book, is entitled “Graphics Programming.” It introduces the graphics features of the Apple II computer used for this book, and then goes on to describe these concepts: plotting simple equations; drawing lines and vectors; creation of simple geometric shapes (rectangles, triangles, polygons, circles) as well as gaming figures (small tanks, jets, cars, rackets, animals); mandalas and other computer art effects, including tunneling; shape shifting, random artwork; detailed drawings and the use of digitizing tables; and, finally, moving figure animation.

The first two chapters of the book can be read any time and will be of help in evaluating which personal computer to buy for graphics work. The third chapter can be studied whether or not you own a computer, but your understanding will certainly be enhanced if one is available to practice the examples on.

Click to Read More

Computer Graphics C Version Second Edition

By Donald Hearn and M. Pauline Baker

Computers have become a powerful tool for the rapid and economical production of pictures. There is virtually no area in which graphical displays cannot be used to some advantage, and so it is not surprising to find the use of computer graphics so widespread. Although early applications in engineering and science had to rely on expensive and cumbersome equipment, advances in computer technology have made interactive computer graphics a practical tool. Today, we find computer graphics used routinely in such diverse areas as science, engineering, medicine, business, industry, government, art, entertainment, advertising, education, and training. Figure 1-1 summarizes the many applications of graphics in simulations, education, and graph presentations. Before we get into the details of how to do computer graphics, we first take a short tour through a gallery of graphics applications.

A major use of computer graphics is in design processes, particularly for engineering and architectural systems, but almost all products are now computer designed. Generally referred to as CAD, computer-aided design methods are now routinely used in the design of buildings, automobiles, aircraft, watercraft, spacecraft, computers, textiles, and many, many other products. For some design applications; objeck are f&t displayed in a wireframe outline form that shows the overall sham and internal features of obiects. Wireframe displays also allow designers to qui'ckly see the effects of interacthe adjustments to design shapes. Figures 1-2 and 1-3 give examples of wireframe displays in design applications.

Click to Download

Java Personal OpenGL Tutorial (JPOT)

The first interactive OpenGL tutor POT was conceived in 1998 by Sumanta Guha, Mahesh Kumar and Ichiro Suzuki at the University of Wisconsin-Milwaukee, for use by the computer graphics students at UWM as well as the graphics community. Since POT ran only on UNIX platforms, we received many requests for versions that could run on other platforms.

Since 1999 Binh Le continued developing the tutorial and created a Java version JPot. This is the current release, and the important features are as follows:

• JPot is platform independent.
• The interface is improved.
• There are more lessons.
• A tool is provided to generate lessons automatically.

As an accademic project, JPot is free for all non-commercial uses, and we are strongly welcome other contributions for JPot. Even though we can not be responsible for any consequence of using it, we still try our best to assist you when you have problem regarding using and working on JPot.

Click to Read More

Using OpenGL in Visual C++

By Alan Oursland

With the release of NT 3.5, OpenGL became a part of the Windows operating system. Now with support for OpenGL in Windows 95 and Windows 98 and low priced graphics accelerators becoming readily available even on low end machines, the prospects of using OpenGL on any Windows machine is becoming more attractive every day. If you are interested in creating quality 2-D or 3-D graphics in Windows, or if you already know another variant of GL, keep reading. This tutorial will show you how to use OpenGL and some of its basic commands.

GL is a programming interface designed by Silicon Graphics. OpenGL is a generic version of the interface made available to a wide variety of outside vendors in the interest of standardization of the language.

OpenGL allows you to create high quality 3-D images without dealing with the heavy math usually associated with computer graphics. OpenGL handles graphics primitives, 2-D and 3-D transformations, lighting, shading, Z-buffering, hidden surface removal, and a host of other features. I'll use some of these topics in the sample programs following; others I'll leave to you to explore yourself. If you want to learn more about OpenGL you can search the MSDN website for the keyword "OpenGL".

Here is the list of topics covered in this series:

1. Writing an OpenGL Program
2. Simple 2-D Graphics
3. Transformations and the Matrix Stack
4. Simple 3-D Graphics

Click to Download

OpenGL Programming Guide Second Edition

The OpenGL graphics system is a software interface to graphics hardware. (The GL stands for Graphics Library.) It allows you to create interactive programs that produce color images of moving three-dimensional objects. With OpenGL, you can control computer-graphics technology to produce realistic pictures or ones that depart from reality in imaginative ways. This guide explains how to program with the OpenGL graphics system to deliver the visual effect you want.

What You Should Know Before Reading This Guide
This guide assumes only that you know how to program in the C language and that you have some background in mathematics (geometry, trigonometry, linear algebra, calculus, and differential geometry). Even if you have little or no experience with computer-graphics technology, you should be able to follow most of the discussions in How to Obtain the Sample Code xxi this book. Of course, computer graphics is a huge subject, so you may want to enrich your learning experience with supplemental reading.

• Computer Graphics: Principles and Practice by James D. Foley, Andries van Dam, Steven K. Feiner, and John F. Hughes (Reading, MA: Addison-Wesley, 1990)—This book is an encyclopedic treatment of the subject of computer graphics. It includes a wealth of information but is probably best read after you have some experience with the subject.
• 3D Computer Graphics: A User’s Guide for Artists and Designers by Andrew S. Glassner (New York: Design Press, 1989)—This book is a nontechnical, gentle introduction to computer graphics. It focuses on the visual effects that can be achieved rather than on the techniques needed to achieve them.

Once you begin programming with OpenGL, you might want to obtain the OpenGL Reference Manual by the OpenGL Architecture Review Board (Reading, MA: Addison-Wesley Developers Press, 1996), which is designed as a companion volume to this guide. The Reference Manual provides a technical view of how OpenGL operates on data that describes a geometric object or an image to produce an image on the screen. It also contains full descriptions of each set of related OpenGL commands—the parameters used by the commands, the default values for those parameters, and what the commands accomplish. Many OpenGL implementations have this same material on-line, in the form of man pages or other help documents, and it’s probably more up-to-date. There is also a http version on the World Wide Web; consult Silicon Graphics OpenGL Web Site (http://www.sgi.com/Technology/openGL) for the latest pointer. OpenGL is really a hardware-independent specification of a programming interface, and you use a particular implementation of it on a particular kind of hardware.

This guide explains how to program with any OpenGL implementation. However, since implementations may vary slightly—in performance and in providing additional, optional features, for example—you might want to investigate whether supplementary documentation is available for the particular implementation you’re using. In addition, you might have OpenGL-related utilities, toolkits, programming and debugging support, widgets, sample programs, and demos available to you with your system.

Click to Download

OpenGL Simple Shading Example -Sample Chapter

Now that we’ve described the OpenGL Shading Language, let’s look at a simple example. In this example, we apply a brick pattern to an object. The brick pattern is calculated entirely within a fragment shader. If you’d prefer to skip ahead to the next chapter for a more in-depth discussion of the API that allows shaders to be defined and manipulated, feel free to do so.

The shader for rendering a procedural brick pattern was the first interesting shader ever executed by the OpenGL Shading Language on programmable graphics hardware. It ran for the first time in March 2002, on the 3Dlabs Wildcat VP graphics accelerator. Dave Baldwin published the first GLSL brick fragment shader in a white paper that described the language destined to become the OpenGL Shading Language. His GLSL shader was based on a RenderMan shader by Darwyn Peachey that was published in the book, Texturing and Modeling: A Procedural Approach. Steve Koren and John Kessenich adapted Dave’s shader to get it working on real hardware for the first time, and it has subsequently undergone considerable refinement for inclusion in this book.

This example, like most of the others in this book, consists of three essential components: the source code for the vertex shader, the source code for the fragment shader, and the application code that initializes and uses these shaders. This chapter focuses on the vertex and fragment shaders. The application code for using these shaders is discussed in Section 7.13, after the details of the OpenGL Shading Language API have been discussed.

Click to Download

OpenGL Texture Mapping - Sample Chapter

After reading this chapter, you’ll be able to do the following:

• Understand what texture mapping can add to your scene
• Specify texture images in compressed and uncompressed formats
• Control how a texture image is filtered as it is applied to a fragment
• Create and manage texture images in texture objects and, if available, control a high-performance working set of those texture objects
• Specify how the color values in the image combine with those of the fragment to which it’s being applied
• Supply texture coordinates to indicate how the texture image should be aligned with the objects in your scene
• Generate texture coordinates automatically to produce effects such as contour maps and environment maps
• Perform complex texture operations in a single pass with multitexturing (sequential texture units)
• Use texture combiner functions to mathematically operate on texture, fragment, and constant color values
• After texturing, process fragments with secondary colors
• Perform transformations on texture coordinates using the texture matrix
• Render shadowed objects, using depth textures

So far, every geometric primitive has been drawn as either a solid color or smoothly shaded between the colors at its vertices—that is, they’ve been drawn without texture mapping. If you want to draw a large brick wall without texture mapping, for example, each brick must be drawn as a separate polygon. Without texturing, a large flat wall—which is really a single rectangle—might require thousands of individual bricks, and even then the bricks may appear too smooth and regular to be realistic.

Texture mapping allows you to glue an image of a brick wall (obtained, perhaps, by scanning in a photograph of a real wall) to a polygon and to draw the entire wall as a single polygon. Texture mapping ensures that all the right things happen as the polygon is transformed and rendered. For example, when the wall is viewed in perspective, the bricks may appear smaller as the wall gets farther from the viewpoint. Other uses for texture mapping include depicting vegetation on large polygons representing the ground in flight simulation; wallpaper patterns; and textures that make polygons look like natural substances such as marble, wood, and cloth. The possibilities are endless. Although it’s most natural to think of applying textures to polygons, textures can be applied to all primitives—points, lines, polygons, bitmaps, and images. Plates 6, 8, 18–21, and 24–32 all demonstrate the use of textures.

Click to Download

The OpenGL Utility Toolkit (GLUT) Programming Interface

By Mark J. Kilgard

The OpenGL UtilityToolkit (GLUT) is a programming interface withANSI C and FORTRAN bindings for writing window system independent OpenGL programs. The toolkit supports the following functionality:

• Multiplewindows for OpenGL rendering.
• Callback driven event processing.
• Sophisticated input devices.
• An “idle” routine and timers.
• A simple, cascading pop-up menu facility.
• Utility routines to generate various solid and wire frame objects.
• Support for bitmap and stroke fonts.
• Miscellaneous window management functions, including managing overlays.

An ANSI C implementation of GLUT for the X Window System [15] has been implemented by the author. Windows NT and OS/2 versions of GLUT are also available.

This documentation serves as both a specification and a programming guide. If you are interested in a brief introduction to programming with GLUT, look for the introductory OpenGL column [9] published in The X Journal. For a complete introduction to using GLUT, obtain the book Programming OpenGL for the XWindow System [10]. GLUT is also used by the 2nd edition of the OpenGL Programming Guide. Teachers and students interested in using GLUT in conjunction with a college-level computer graphics class should investigate Angel’s textbook Interactive Computer Graphics: A top-down approach with OpenGL [2] that uses GLUT for its OpenGL-based examples programs.

The remainder of this section describes GLUT’s design philosophy and usagemodel. The following sections specify the GLUT routines, grouped by functionality.

The final sections discuss usage advice, the FORTRAN binding, and implementation issues. AppendixA enumerates and annotates the logical programmer visible state maintained by GLUT. Appendix B presents the ANSI C GLUT API via its header file. Appendix C presents the FORTRAN GLUT API via its header file.

Click to Download

OpenGL Tutorial

OpenGL is a low-level graphics library specification. OpenGL makes available to the programmer a small set of geometric primitives - points, lines, polygons, images, and bitmaps. OpenGL provides a set of commands that allow the specification of geometric objects in two or three dimensions, using the provided primitives, together with commands that control how these objects are rendered into the frame buffer.

The OpenGL API was designed for use with the C and C++ programming languages but there are also bindings for a number of other programming languages such as Java, Tcl, Ada, and FORTRAN.

The OpenGL 1.1 Specification is maintained by Silicon Graphics and can be found at: http://www.sgi.com/Technology/openGL/glspec1.1/glspec.html.

Mesa is a free implementation of the OpenGL specification. Mesa is the actual graphics library that will be used in this course. Additional information on Mesa can be found at: http://www.ssec.wisc.edu/~brianp/Mesa.html.

The OpenGL specification is operating system and windowing system independent. It relies on the windowing system for window management, event handling, color map operations, etc . . .. In this course the tk library will be used for windowing system functions. (This library is not to be confused with Tk of Tcl/Tk.) The tk library provides the "glue" between OpenGL and X Windows.

Following are the content of this tutorial

1. Introduction to OpenGL
Rendering Pipeline
Libraries
Include Files
Setting Up Compilers

2. Simple OpenGL Program
Initialization
Creating a Window
Display Function
Reshape Function
Main Loop

3. Geometric Objects
Points, Lines and Polygons
Drawing 3-D Objects
Transformations
Scaling
Translation
Rotation Display Lists

4. Viewing
Color
Shading
Viewing Transformation
Projection
Orthographic
Perspective Manipulating the Matrix Stacks
Light
Viewport Transformation

5. Input Devices and Interaction
Menu
Mouse
Keyboard
Animation

6. Selection
Name Stacks
Picking
Hits

Click to Read More

Teach Yourself Illustrator 7 in 24 Hours

By Mordy Golding

"Teach yourself Illustrator in 24 hours?" Yeah, right. I'll bet you're thinking you could probably learn how to do a triple-bypass open heart procedure before you could learn Adobe Illustrator (those guys on E.R. make it look so easy). But it can be done, and this book is the perfect way to learn how. I've broken down the entire application into easy-to-understand chapters, and before you know it, you'll be a proficient Illustrator user. Trust me, it's a lot simpler than medical school...

If you've already picked up the book and started reading, you're probably interested in learning Illustrator, and--Behold! This book was written for anyone who wants to learn Illustrator! Whether you're an experienced Photoshop user who wants to enjoy the precise illustration benefits of Illustrator, a FreeHand convert, an experienced Illustrator user who wants to get up to speed with the new version 7, or a beginner, this book is a great way to quickly learn Illustrator.

Click to Read More

Teach Yourself Photoshop® in 14 Days

By Bront Davis, Carla Rose and Steve Mulder

Adobe Photoshop is without a doubt one of the most powerful image editors on the market today, if not the most powerful. It offers professional-level capabilities in print and electronic media. The trick is to learn how to put it to use, maximizing its power and capabilities, yet minimize the time it takes to accomplish what you need to do. And that's just what you are going to learn in this book.

Teach Yourself Photoshop in 14 Days is going to be your help and your guide--at least to start. The stated goal is to make you not only proficient in the basics of Photoshop, but to create a learning environment in which you feel comfortable enough to experiment, test, and develop your own tips, tricks, and ultimately, skills.

This book will show you everything from the basics of opening files, manipulating selections, and working with layers all the way to creating images for publishing on the World Wide Web.

The skills build from chapter to chapter, starting at the basics and moving on to more complex techniques, but I have tried to make each day modular enough so that you can dive in and pick up a skill or technique no matter what day you are currently working on. And if you are having problems, consult the index for an answer.

The CD-ROM that accompanies this book contains all the files used in the tutorials. The files are at all stages of completion so that you might get a better sense of what is really happening as we examine different processes.

Notes are scattered throughout the chapters. These focus on higher-level techniques, tricks, and information that is not essential but useful. Use them to supplement your understanding of Photoshop.

Without further discussion, let's begin our 14-day journey through the basics of this fascinating and incredibly powerful software.

Click to Read More

Introduction to Adobe Photoshop

extropia.com

Adobe Photoshop is hands down, the most popular program for creating and modifying images for the web.

This is true not only because Photoshop is available on a wide array of platforms ranging from Mac to Windows to UNIX, but because after four generations of development, Adobe Photoshop has the most intuitive user interface, the most complete set of tools, and the largest number of reference books around.

In fact, as Deke McClelland says in Photoshop 3 Bible, "Some estimates say that Photoshop sales exceed those of all of its competitors combined."

Photoshop is only one tool in a good designer's arsenal. Other popular tools include Paint Shop Pro, DeBabelizer, or LView Pro for Windows and GIF Converter or Graphics Converter for Macintosh. Fractal Design, Aldus and HSC also put out some excellent programs

Kenji Tachibana (a gifted freelance graphics artist) and I decided to focus on Photoshop primarily because Photoshop is the program that most web designers use.

However, since most programs these days use similar concepts, many of the things we talk about here will be directly relevant to any other graphics program on the market.

Click to Read More

VRML Tutorial

By Markus Roskothen

You are hungry for VRML? You have no clue what the VRML specification is talking about? You want to *l-earn* it from the ground up? Then dive right in and let me help you learn the basics.

All the tutorials are original and tested. Please look for the symbols at the beginning of each section, e.g. 'WV2' stands for WorldView2 and 'CP2' stands for CosmoPlayer2. I focus on these VRML browsers mainly because I am too lazy to check other ones.

All you need to start is a copy of the VRML specification, a text editor (SitePad), and of course a VRML plugin (WorldView or CosmoPlayer). Have fun and let me know whether you liked it.If you are looking for literature I can recommend a few books to you:

The VRML 2.0 Sourcebook is the Bible of VRML. All the nodes are explained with samples and the hypertext version is very useful. Late Night Vrml 2.0 with Java is the book of choice if you want to get into Java scripting. If you don't like the very technical VRML2.0 specification you might want to check out The Annotated VRML 2.0 Reference Manual. This book explains all nodes in great detail.

A spartan version of the tutorials (58 kb) can be downloaded for offline learning.

Click to Read More

VRML Primer and Tutorial

By Daniel K. Schneider and Sylvere Martin-Michiellot

The Virtual Reality Modeling Language (VRML) can been seen as a 3-D visual extension of the WWW. People can navigate through 3-D space and click on objects representing URLs (including other VRML worlds). Often, VRML is pronounced like ``Vermal'', not ``V-R-M-L''.

As Mark Pesce [Pesce, 1995, p. 16] points out, the WWW had two fundamental dimensions: connectivity (the http protocol) and interface (i.e. the rendering of content, especially HTML and embedded URLS). VRML inserts itself seamlessly in the Web's connectivity. VRML browsers can access other VRML files via an URL. They can access any other format that then is passed to another application (e.g. an HTML browser or a HTML window). On the other hand HTML browsers can be configured to fire up VRML helper applications (or plug-ins). HTTP servers, finally, can be configured to tell the client that a VRML (*.wrl) document is transferred.

A short word on its history: The major impulse for VRML can be traced back to a ``birds of the feature sessions'' on ``Virtual Reality Markup Languages'' at the First International Conference on the World-Wide-Web, May 25-27, 1994 at CERN in Geneva. It's conceptual origins are older, e.g. (a) Science Fiction literature (e.g. [Gibson, 1994], [Stephenson, 1992]), (b) Mark Pesce's, P. Kennard's and Toni Parisi's ``Labyrinth'' system ([Pesce et al., 1994]) and proposal for a 3-D navigation and representation scheme and (c) more generally 3-D computer graphics (including VR). Based upon SGI's ``Open Inventor'' format, a almost final draft for VRML 1.0 was presented at the second WWW conference in fall 94 in Chicago. On April 3, 1995 SGI presented WebSpace, the first publicly available VRML browser. So all in all it took about a year to set standards and make the first browser available. Since VRML is a relatively simple format building upon a well defined standard, very quickly a number of modeling tools and convertors also became available.

In the next sections we will look at simple static VRML scences. These are built with VRML's symbolic description language. Note different VRML browsers all have a different user interface (e.g. for navigation and object examination). They also render things a bit differently. Most will also give you a ``quality'' choice (e.g. faster renderning and lower quality vs. slower rendering but better quality. For now, let's just assume that the user can move himself though 3D space by moving a camera through the space (and therefore what he sees on the display is what sees ``his'' camera).

Click to Read More

VRML Interactive Tutorial

By Antonio Ramires Fernandes

Hi, thank you for visiting my VRML Interactive Tutorial.

Good news for IE users! You can now fully benefit from this tutorial. I've updated the Try It Yourself section so that you can play with the worlds and update the VRML.

This tutorial covers the basics of VRML97 providing limitless source code due to its interactivity. Look for the "TIY" (Try it yourself") button on the top of some of the pages. Pressing this button opens a new window where you can play with the parameters and view the results. Source code using your parameters is also provided.

The left frame provides an index to the tutorial. There are sections about specific nodes as well as concepts required to fully understand all the fields involved.

This tutorial is likely to have bugs, and concepts which are not clearly explained. Please e-mail me, press the BUGS button, with bugs and suggestions. These e-mails will be much appreciated and will help me to provide a good tutorial.

I hope you enjoy the tutorial,

Click to Read More

VRML Audio Tutorial

This is a guide to learning how to implement sound in VRML 2.0 files. It's assumed you know a bit about VRML 2.0 and its basic features and functions. You will also need Cosmoplayer to view and hear the examples. For best results, use headphones or be centered between a pair of speakers that are facing out parallel to each other.

Introduction

The VRML 2.0 specification allows for the implementation of spatialized, 3D audio in a world. Spatial audio is sound that has been processed to give the listener a sense of the location of a virtual sound source in a virtual listening space. The process involves the use of Head-Related Transfer Function (HRTF) algorithms that mimic the way humans intercept and perceive sound, specifically the reflections off the pinnae (outer ear) and shoulder, as well as the shadowing effect of the head itself. This gives a heightened sense of immersion and realism in a virtual environment. The uses of spatial audio in a virtual world range from music and sound effects for entertainment to aural navigation for the visually impaired. As more uses for audio are implemented into virtual worlds, it will likely become as neccessary as graphics in order to create a quality experience.

Click to Read More

Texture Mapping in VRML

by Cindy Ballreich

The purpose of this page is to describe how textures ought to work if you follow the VRML specifications, not necessarily how they actually do work. Many of the browsers out there only support part of the spec, and a few probably don't support it correctly. The examples posted here for VRML 1.0 have been tested with WebSpace 1.1 for SGI and the examples for VRML 2.0 have been tested with CosmoPlayer beta2 for SGI. Both of these browsers seem to support the spec fairly well. If you encounter problems displaying any of these examples, you've probably uncovered a browser related problem. I'll try to point out areas that cause problems with browsers when I can.

Whenever you see the word "example" highlighted on the page, you can click on it to see a VRML illustration of the process being discussed. I've put copies of the examples in the text to make it easier to see the syntax. I would suggest that you save the examples to your disk and modify them to help you understand the concepts we'll be talking about. Several people have asked me to make an archive containing all of the examples available for downloading. The archive for the VRML 1.0 section is called tex-examples.tar.gz.

There are several good books about VRML on the market and all of them discuss texture mapping. I would suggest that anyone interested in VRML get one or two and read up on the subject. Rest assured that any book you find will be at least partially out of date by the time it's published, but the basic information will still be very useful.

Click to Read More

Introduction to VRML

VRML 2.0 is a scene description language which is human readable. There is currently no ratified API associated with VRML. The language has the following capabilities:

• Built in geometric primitives including face sets and solids
• Lighting, material, texure, movie control
• Spatialised sound
• Absolute time for animations
• The concept of an avatar to allow collision detection
• Hyperlinking, viewpoints and navigation methods
• The ability to extend the language through prototyping
• Event handling to detect when geometry is interacted with in some way
• Routing of events to allow one object to affect another
• Scripting in various languages which allows logic in the world

VRML files describe a scene graph structure which is parsed by a browser. The browser may be a plug-in for a web browser or a helper application.The scene graph is composed of nodes which fall into two categories, grouping nodes and others. These nodes may have routes between them, above and beyond the scene graph hierarchy, which define the possible interactions of one node with another. Nodes have fields which define what actual values the node has associated with it.

Within this scene graph certain special nodes, known as bindable, have stacks associated with them which allow them to be pushed and popped to control certain world parameters.

Confused? Don't be, all this is explained in the concepts sections. The bottom line is this, it has never been easier to write 3D graphics.

Click to Read More

Introduction to VRML 97

By David R. Nadeau

VRML (the Virtual Reality Modeling Language) has emerged as the de facto standard for describing 3-D shapes and scenery on the World Wide Web. VRML’s technology has very broad applicability, including web-based entertainment, distributed visualization, 3-D user interfaces to remote web resources, 3-D collaborative environments, interactive simulations for education, virtual museums,virtual retail spaces, and more. VRML is a key technology shaping the future of the web.

Participants in this tutorial will learn how to use VRML 97 (a.k.a. ISO VRML, VRML 2.0, and Moving Worlds) to author their own 3-D virtual worlds on the World Wide Web. Participants will learn VRML concepts and terminology, and be introduced to VRML’s text format syntax. Participants also will learn tips and techniques for increasing performance and realism. The tutorial includes numerous VRML examples and information on where to find out more about VRML features and use.

These tutorial notes primarily contain two types of information:

• General information, such as this preface
• Tutorial slides and examples

The tutorial slides are arranged as a sequence of 500+ hyper-linked pages containing VRML syntax notes, VRML usage comments, or images of sample VRML worlds. Clicking on a sample world’s image, or the file name underneath it, loads the VRML world into your browser for you to examine yourself.

You can view the text for any of the VRML worlds using a text editor and see how I created a particular effect. In most cases, the VRML files contain extensive comments providing information about the techniques the file illustrates.

The tutorial notes provide a necessarily terse overview of VRML. I recommend that you invest in one of the VRML books on the market to get thorough coverage of the language. I am a co-author of one such VRML book, The VRML 2.0 Sourcebook. Several other good VRML books are on the market as well.

Click to Download

3D Graphics & VRML 2.0

by Laura Lemay, Justin Couch and Kelly Murdock

As you can see from the title, this book really has a split personality-the first half is about 3D graphics and the second is about VRML. However, these two topics are very closely related. VRML scenes are 3D graphics, and 3D graphics are used in VRML scenes.

3D graphics on the Web are pervasive because they are graphics. VRML on the Web is a hot new technology that enables real-time 3D. By covering both, you get a broader look at how to enhance your site with many facets of 3D graphics, instead of just one.

In the past, we've all marveled at this technology from a distance. We've seen it in movies, in arcades, and in some of the latest research environments; now we're seeing it on our home pcs. The power of current processors coupled with 3D acceleration cards are making it possible to experience advanced 3D graphics everywhere, especially on the Web.

To begin, we will introduce this unique series, 3D graphics on the Web, and VRML 2.0. A lot is included, and there's a lot you can get out of it.

Click to Read More

Simulating Humans: Computer Graphics, Animation and Control

By Norman I. Badler, Cary B. Phillips and Bonnie L. Webber

The decade of the 80's saw the dramatic expansion of high performance computer graphics into domains previously able only to irt with the technology. Among the most dramatic has been the incorporation of real-time interactive manipulation and display for human gures. Though actively pursued by several research groups, the problem of providing a virtual or synthetic human for an engineer or designer already accustomed to Computer-Aided Design techniques was most comprehensively attacked by the Computer Graphics Research Laboratory at the University of Pennsylvania. The breadth of that effort as well as the details of its methodology and software environment are presented in this volume.

This book is intended for human factors engineers requiring current knowledge of how a computer graphics surrogate human can augment their analyses of designed environments. It will also help inform design engineers of the state-of-the-art in human gure modeling, and hence of the human-centered design central to the emergent notion of Concurrent Engineering. Finally, it documents for the computer graphics community a major research effort in the interactive control and motion specification of articulated human figures.

Click to Download

Graphics Programming in Icon

By Ralph E. Griswold, Clinton L. Jeffery, and Gregg M. Townsend

Graphics -- presenting data in understandable ways and providing a visual interface for users (GUI) -- should be a central part of most computer applications. In most programming languages, however, graphics facilities are an add-on -- and they are so difficult to use that they often are avoided. Icon solves this problem by providing high-level, easy-to-use graphics facilities that are fully integrated with the rest of the language.

This book complements The Icon Programming Language by providing a complete self-contained description of graphics concepts, how they are cast in Icon, and how to use them in programming.

Low-level languages like C and C++ use add-on graphics libraries that demand complex, voluminous code to address many tedious details. The high-level graphics features in the powerful Icon programming language are integrated with the rest of the language; graphics code is short and easy to write. You don't need years of experience with arcane techniques - you can get impressive results with just a few lines of Icon code.

Using Icon you can draw, use colors and fonts, create images, do simple animations, and build powerful applications with visual interfaces (GUIs). Look inside for a hint of what's possible.

This book is self-contained. It has all you need to understand and use graphics in your programming, including how to program in Icon. Many carefully explained program examples guide you through the exciting world of graphics. Before long, you can be creating your own computer graphics.

Click to Download

Encyclopedia of Graphics File Formats, Second Edition

by James D. Murray and William vanRyper

This book is primarily for graphics programmers, but it's also for application programmers who need to become graphics programmers (if only for a little while). Although we didn't anticipate, in the first edition, that the book would be useful to graphics illustrators, we found that it was. In this second edition of the book and the CD-ROM, we've tried to provide additional resources for this audience. The book is also for anyone who needs a quick way to identify a graphics file of unknown origin. If you're not a graphics programmer, but want to get up to speed quickly, you'll find that Part One of the book requires little prior knowledge of computer graphics. It will help you become familiar with concepts associated with the storage of graphics data. In fact, a working knowledge of a programming language is useful, but not absolutely essential, if you're only looking for the big picture.

If you just want some background on graphics file formats, you might want to read Part One and refer, as needed, to the articles in Part Two and the appendices in Part Three. If you're in search of implementation guidance, you will want to refer to the articles and example code. Of course if you're a computer graphics professional, you might be interested primarily in the specification documents and tools on the CD-ROM.

In the unlikely event that you are creating your own new graphics file format, we fervently hope that this book provides you with some perspective on your task, if only by exhibiting the decisions--good and bad--that are frozen in the formats described in these pages.

This book is divided into three parts.

Part One, Overview, is an introduction to those computer graphics concepts that are especially helpful when you need to work with graphics file formats.

• Chapter 1, Introduction, introduces some basic terminology, and gives an overview of computer graphics data and the different types of graphics file formats used in computer graphics. This chapter also lists all of the formats described in this book.
• Chapter 2, Computer Graphics Basics, discusses some concepts from the broader field of computer graphics that are necessary for an understanding of the rest of the book.
• Chapter 3, Bitmap Files, describes the structure and characteristics of bitmap files.
• Chapter 4, Vector Files, describes the structure and characteristics of vector files.
• Chapter 5, Metafiles, describes the structure and characteristics of metafiles.
• Chapter 6, Platform Dependencies, describes the few machine and operating system dependencies you will need to understand.
• Chapter 7, Format Conversion, discusses issues to consider when you are converting between the different format types (e.g., bitmap to vector), as well as between formats within a type (e.g., vector to vector).
• Chapter 8, Working With Graphics Files, describes the issues that come up when you read, write, and test graphics files. It also covers the corruption and encryption of graphics files, the potential for virus infection in those files, and the issues involved in writing your own file formats and file format specifications, including copyright issues.
• Chapter 9, Data Compression, describes data compression, particularly as compression techniques apply to graphics data and the graphics files described in this book.
• Chapter 10, Multimedia, surveys multimedia formats and issues.

Part Two, Graphics File Formats, describes the graphics file formats themselves. There is one article per format or format set, and articles are arranged alphabetically. Each article provides basic classification information, an overview, and details of the format. In many cases we've included short code examples. We've also indicated whether the specification itself (or an article that describes the details of the format) is included on the CD-ROM, as well as code examples and images encoded in that format. Also provided in the articles are references for further information.

Part Three, Appendices, contains the following material:

• Appendix A, Graphics Files and Resources on the Internet, describes how to use a variety of information services on the Internet (email, USENET, FTP, Archie, and the World Wide Web) to obtain, post, and otherwise deal with graphics files. It includes a listing of recommended sources of information about computer graphics and graphics file formats.
• Appendix B, Graphics Files and Resources on the Commercial Services, provides pointers to information about graphics files and resources on CompuServe, America Online, and a variety of bulletin board systems (BBSs).
• Appendix C, Installation and Setup, describes how to get the online product up and running on your system.

Click to Read More

Basic Graphics Programming With The Xlib Library

This tutorial is the first in a series of "would-be" tutorials about graphical programming in the X window environment. By itself, it is useless. A real X programmer usually uses a much higher level of abstraction, such as using Motif (or its free version, lesstiff), GTK, QT and similar libraries. However, we need to start somewhere. More than this, knowing how things work down below is never a bad idea.

After reading this tutorial, one would be able to write very simple graphical programs, but not programs with a descent user interface. For such programs, one of the previously mentioned libraries would be used.

The Client And Server Model Of The X Window System
The X window system was developed with one major goal - flexibility. The idea was that the way things look is one thing, but the way things work is another matter. Thus, the lower levels provide the tools required to draw windows, handle user input, allow drawing graphics using colors (or black and white screens), etc. To this point, a decision was made to separate the system into two parts. A client that decides what to do, and a server that actually draws on the screen and reads user input in order to send it to the client for processing.

Click to Read More

Visualization

By Pat Hanrahan

This ebook on computer graphics covers visualization in depth. Following are the topics covered in this ebook.

• The Purpose of Visualization
  Information visualization, Card, Mackinlay, Schneiderman (handout)
  Spatial schemas in depictions, Tversky (handout)
  Decision to launch the Challenger, Tufte (handout)
• Data and Image Models
  The eyes have it, Schneiderman (html)
  Bertin and beyond, Green (html)
  The structure of the information visualization design space, Card, Mackinlay (pdf)
• Discussion of examples of good and bad visualizations
• Perception and Cognition
  Small Multiples, In Envisioning Information
  Layering, In Envisioning Information
  Graphical perception, Spence and Lawandowsky (handout)
  Integral vs. separable dimensions, Palmer (handout)
  Graphical perception, Cleveland and McGill (html).
  Demonstrations
  Healey's preattentive vision applet
  Rensink's change blindness applet
  The Game of Set
• Design Problem I
  Diffusion tensor MRI, Dave Akers, Rachel Mackenzie
  Ancestral trees, Jeff Klingner, Merrie Ringel
• Space (On Being in the Right Space)
  Escaping flatland, In Envisioning Information
  Narratives of space and time, In Envisioning Information
  Map Projections in PDF
  Postmortem of an example, Bertin (handout)
  A tour of Trellis graphics, R. Becker et al. (ps)
  Table lens, Rao and Card, (acm)
• Design Problem II
  C++ classes and methods, Mike Cammarano, Daniel Horn
  Network intrusion detection, Amir Lopatin, John Gerth
• Color
  Color and information, In Envisioning Information
  Abstracting reality, MacEachren (handout)
  Area Colors, Imhof (handout), Virtual Library
  PRAVDA, Bergman, Treinish, Rogowitz
  Color guidelines, Brewer
  CIELUV and CIELAB Applets, P. Rhodes
• Design Problem III
  Gene arrays, Johann Won, Jessy Kang
  Flows of people and commodities, Ron Yeh, Doantam Phan
• Interaction
  Dynamic queries, Ahlberg, C. and Shneiderman, B., (html)
  Dynamic queries, starfield displays, and the path to Spotfire, html.
  Demonstrations and videos
  ggobi
  Excentric labels
  Homefinder
  Cellphones
  Fry's zipcodes
  Attribute explorer and cone tree video
  Table lens
• Design Problem IV
  User event logs (VIBE), Kjell Reutersward, Stace Peterson
  Social networks, Mike Choy, Jed Crosby
  Light fields, Bill Chen, Chris Hong
• Trees and Graphs
  Rheingold-Tilford (handout)
  Kamada-Kawai (handout)
  DOI-tree (html)
  dot paper, Gansner et al. (pdf)
• Self Illustrating Phenomena
• Temporal Photography
• Conveying Shape: Line Drawings
  Dooley, Cohen, Line illustration (handout)
  Hayes, Ross, Lines of sight (handout)
  DeCarlo, et al, Suggestive contours (html)
• Conveying Shape: Shading and Texturing
  Gooch and Gooch, Communicating shape
  Ramachandran, 2-D or not 2-D--that is the question (handout)
  Interrante, Texture
  Akers et al. Conveying shape with image-based relighting
• Animation
  Principles, Lasseter, (acm)
  Animation: Can it facilitate?, B. Tversky et al., (handout)
  Slithy, (html)
• Graphical Integrity
  Graphical integrity, Tufte, (handout)
  Every map shows this, but not that, Wood, (handout)

Click to Read More/Download

Real-Time Graphics Architectures

By Kurt Akeley and Pat Hanrahan

High-performance 3D graphics systems are now a part of almost every personal computer. In fact, the two major computational components of a PC are its main processor (CPU) and its graphics processor (now being referred to as the GPU). This course covers the architecture of graphics chips and systems. Topics include the key components of the graphics pipeline including the display, framebuffer, rasterization, texturing and geometry processing stages. More general topics include how graphics chips are different than main processors, and how to quantitatively model and evaluate graphics systems. Finally, we will cover trends in graphics hardware including programmable shading and ray tracing architectures. This course is targetted to both systems students interested in building graphics systems, as well as programmers interested in real-time graphics applications such as games.

Topics covering in detail

• Introduction (Kurt, Pat)
• The graphics pipeline (Pat)
• Nuts and bolts (Kurt)
• Performance analysis and characterization (Pat)
• Framebuffers and displays (Kurt)
• Rasterization (Kurt)
• Texturing (Pat)
• Geometry (Kurt)
• Parallelism and communication (Pat)
• Trends in Graphics Architectures, Tim Van Hook, ATI
• UNC High Performance Graphics Hardware, Anselmo Lastra, UNC
• Antialiasing (Kurt)
• Advanced texturing and shading (Pat)
• Programmable shading (Pat)
• Ray tracing (Pat)
• System issues (Kurt)
• The Design of OpenGL (Kurt)
• The Design of RenderMan (Pat)
• Final thoughts

Click to Read More/Download

Computer Graphics: Image Synthesis Techniques

By Pat Hanrahan

This image synthesis techniques ebook explains

• The Goals of Rendering
• Ray Tracing I: Basic Algorithm, Ray-Surface Intersection
• Ray Tracing II: Acceleration Techniques
• The Light Field
• Lights and Lighting, Illumination
• Camera and Film
• Sampling and Reconstruction, Aliasing and Antialiasing
• Statistical Sampling
• Reflection Models I: BRDFs, Ideal Specular and Diffuse
• Reflection Models II: Glossy
• Texture
• The Rendering Equation
• Monte Carlo Methods I: Probability, Sampling and Variance Reduction
• Monte Carlo Methods II: Sampling Paths
• Monte Carlo Methods III: Irradiance Caching and Photon Maps
• Radiosity I: Form Factors, Solvers
• Radiosity II: Meshing and Hierarchical Techniques
• Volume Rendering

Image Synthesis Techniques

Three aspects

• Lights and Lighting
  Light sources
  Illumination algorithms
• Materials
  Reflection models
  Texture models
• Camera
  Lens and film effects

Fundamentally involves physical modeling and simulation.

‘60-’70’s : Geometric Aspects

Transformation/clipping

• Evans and Sutherland display pipeline

Hidden line and surface algorithms

• Sutherland, Sproull, Shumacker sort taxonomy
• Object vs. Image space

Simple shading and texturing

• Gouraud: interpolating colors
• Phong: interpolating normals
• Blinn, Catmull, Williams texturing

Click to Read More/Download

Computer Graphics - cc.gatech.edu

This computer graphics ebook covers 2D Raster Graphics Algorithms, Geometrical Transformations, Viewing in 3D, Representing Curves and Surfaces, Visible Surface Determination, Illumination & Shading, and Animation.

Topic covers in detail-

1. 2D Raster Graphics Algorithms
   Scan Converting Lines
   Scan Converting Circles
   Scan Converting Polygons
   Fillings Rectangles
   Fillings Polygons
   Clipping Lines
   Clipping Polygons
   Antialiasing
2. Geometrical Transformations
   Primitive Transformations
   Homogeneous Coordinate Systems
   Composition of Transformations
   Window-to-Viewport Transformation
   3-D Transformations
   Composition of 3-D Transformations
3. Viewing in 3D
   Projections
   Specifying an Arbitrary 3D View
   Clipping
   Mathmatics
   Coordinate Systems
4. Representing Curves and Surfaces
   Polygon Meshes
   Modeling Curves
   Quadric Surfaces
5. Visible Surface Determination
   Hidden Surface Removal
   Algorithms
   Visible-surface ray tracing
6. Illumination and Shading
   Illuminations Models
   Ray Tracing
   Shading Models
7. Animation
   Computer-Assisted Animation
   Rules of Animation
   Controlling Animation

Click to Read More

Computer Graphics - cs.brown.edu

By Andries van Dam

Introduction

What is Computer Graphics?

• Computer graphics generally means creation, storage and manipulation of models and images
• Such models come from diverse and expanding set of fields including physical, mathematical, artistic, biological, and even conceptual (abstract) structures
• William Fetter coined term “computer graphics”in 1960 to describe new design methods he was pursuing at Boeing
• Created a series of widely reproduced images on pen plotter exploring cockpit design, using 3D model of human body.
• Perhaps the best way to define computer graphics is to find out what it is not. It is not a machine. It is not a computer, nor a group of computer programs. It is not the know-how of a graphic designer, a programmer, a writer, a motion picture specialist, or a reproduction specialist.

• Computer graphics is all these –a consciously managed and documented technology directed toward communicating information accurately and descriptively.”
  
  Computer Graphics, by William A. Fetter, 1966
  
  Click to Download