Download full Computer graphics through openGL Third Edition Guha ebook all chapters
Download full Computer graphics through openGL Third Edition Guha ebook all chapters
com
https://textbookfull.com/product/computer-graphics-through-
opengl-third-edition-guha/
OR CLICK BUTTON
DOWNLOAD NOW
https://textbookfull.com/product/computer-graphics-through-opengl-
from-theory-to-experiments-sumanta-guha/
textboxfull.com
https://textbookfull.com/product/computer-graphics-programming-in-
opengl-using-c-third-edition-gordon-phd/
textboxfull.com
https://textbookfull.com/product/computer-graphics-programming-in-
opengl-with-java-gordon/
textboxfull.com
https://textbookfull.com/product/introduction-to-computer-graphics-
with-opengl-es-first-edition-junghyun-han/
textboxfull.com
Computer Graphics Programming in OpenGL with Java 2nd
Edition V. Scott Gordon
https://textbookfull.com/product/computer-graphics-programming-in-
opengl-with-java-2nd-edition-v-scott-gordon/
textboxfull.com
https://textbookfull.com/product/learn-opengl-learn-modern-opengl-
graphics-programming-in-a-step-by-step-fashion-1st-edition-joey-de-
vries/
textboxfull.com
https://textbookfull.com/product/r-graphics-third-edition-paul-
murrell/
textboxfull.com
https://textbookfull.com/product/fundamentals-of-computer-graphics-
steve-marschner/
textboxfull.com
https://textbookfull.com/product/mathematics-for-computer-graphics-
john-vince/
textboxfull.com
Computer Graphics Through OpenGL
From Theory to Experiments
Third Edition
Computer Graphics Through OpenGL
From Theory to Experiments
Third Edition
Sumanta Guha
Asian Institute of Technology, Thailand
Cover Designed by Sumanta Guha
CRC Press
Taylor & Francis Group
6000 Broken Sound Parkway NW, Suite 300
Boca Raton, FL 33487-2742
This book contains information obtained from authentic and highly regarded sources. Reasonable efforts have been made to publish reliable data and
information, but the author and publisher cannot assume responsibility for the validity of all materials or the consequences of their use. The authors and
publishers have attempted to trace the copyright holders of all material reproduced in this publication and apologize to copyright holders if permission
to publish in this form has not been obtained. If any copyright material has not been acknowledged please write and let us know so we may rectify in any
future reprint.
Except as permitted under U.S. Copyright Law, no part of this book may be reprinted, reproduced, transmitted, or utilized in any form by any electronic,
mechanical, or other means, now known or hereafter invented, including photocopying, microfilming, and recording, or in any information storage or
retrieval system, without written permission from the publishers.
For permission to photocopy or use material electronically from this work, please access www.copyright.com (http://www.copyright.com/) or contact
the Copyright Clearance Center, Inc. (CCC), 222 Rosewood Drive, Danvers, MA 01923, 978-750-8400. CCC is a not-for-profit organization that provides
licenses and registration for a variety of users. For organizations that have been granted a photocopy license by the CCC, a separate system of payment
has been arranged.
Trademark Notice: Product or corporate names may be trademarks or registered trademarks, and are used only for identification and explanation
without intent to infringe.
P REFACE XVII
I Hello World 1
1 A N I NVITATION TO C OMPUTER G RAPHICS 3
1.1 Brief History of Computer Graphics . . . . . . . . . . . . . . . . . . . 5
1.2 Overview of a Graphics System . . . . . . . . . . . . . . . . . . . . . . 8
1.2.1 Input Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.2 Output Devices . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Quick Preview of the Adventures Ahead . . . . . . . . . . . . . . . . . 14
8 T RIANGULATION 241
8.1 Definition and Justification . . . . . . . . . . . . . . . . . . . . . . . . 241
8.2 Steiner Vertices and the Quality of a Triangulation . . . . . . . . . . . 244
8.3 Triangulation in OpenGL and the Trouble with Non-Convexity . . . . 245
8.4 Summary, Notes and More Reading . . . . . . . . . . . . . . . . . . . . 248
9 O RIENTATION 249
9.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
9.2 OpenGL Procedure to Determine Front and Back Faces . . . . . . . . 250
9.3 Consistently Oriented Triangulation . . . . . . . . . . . . . . . . . . . 255
9.4 Culling Obscured Faces . . . . . . . . . . . . . . . . . . . . . . . . . . 259
9.5 Transformations and the Orientation of Geometric Primitives . . . . . 261 ix
CONTENTS 9.6 Summary, Notes and More Reading . . . . . . . . . . . . . . . . . . . . 262
12 T EXTURE 379
12.1 Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
12.2 Texture Space, Coordinates and Map . . . . . . . . . . . . . . . . . . . 382
12.3 Repeating and Clamping . . . . . . . . . . . . . . . . . . . . . . . . . . 385
12.4 Filtering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
12.5 Specifying the Texture Map . . . . . . . . . . . . . . . . . . . . . . . . 393
12.5.1 Parametrized Surfaces . . . . . . . . . . . . . . . . . . . . . . . 393
12.5.2 Bézier and Quadric Surfaces . . . . . . . . . . . . . . . . . . . 394
12.5.3 Spheres and Mercator Projection . . . . . . . . . . . . . . . . . 395
12.6 Texture Matrix and Animating Textures . . . . . . . . . . . . . . . . . 397
12.7 Lighting Textures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397
12.8 Multitexturing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
12.9 Rendering to Texture with Framebuffer Objects . . . . . . . . . . . . . 401
12.10 Summary, Notes and More Reading . . . . . . . . . . . . . . . . . . . 405
19 H ERMITE 591
19.1 Hermite Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
19.2 Natural Cubic Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
19.3 Cardinal Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
19.4 Hermite Surface Patches . . . . . . . . . . . . . . . . . . . . . . . . . . 597
19.5 Summary, Notes and More Reading . . . . . . . . . . . . . . . . . . . . 599
Appendices 657
A P ROJECTIVE S PACES AND T RANSFORMATIONS 657
A.1 Motivation and Definition of the Projective Plane . . . . . . . . . . . . 658
A.2 Geometry on the Projective Plane and Point-Line Duality . . . . . . . 660
A.3 Homogeneous Coordinates . . . . . . . . . . . . . . . . . . . . . . . . . 660
A.4 Structure of the Projective Plane . . . . . . . . . . . . . . . . . . . . . 662
A.4.1 Embedding the Real Plane in the Projective Plane . . . . . . . 662
A.4.2 A Thought Experiment . . . . . . . . . . . . . . . . . . . . . . 662
A.4.3 Regular Points and Points at Infinity . . . . . . . . . . . . . . 663
A.5 Snapshot Transformations . . . . . . . . . . . . . . . . . . . . . . . . . 665
A.6 Homogeneous Polynomial Equations . . . . . . . . . . . . . . . . . . . 669
A.6.1 More About Point-Line Duality . . . . . . . . . . . . . . . . . 670
A.6.2 Lifting an Algebraic Curve from the Real to the Projective Plane 671
A.6.3 Snapshot Transformations Algebraically . . . . . . . . . . . . . 674
A.7 The Dimension of the Projective Plane and Its Generalization to Higher
Dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674
A.8 Projective Transformations Defined . . . . . . . . . . . . . . . . . . . . 675
A.9 Projective Transformations Geometrically . . . . . . . . . . . . . . . . 676
A.10 Relating Projective, Snapshot and Affine Transformations . . . . . . . 681
xiv A.10.1 Snapshot Transformations via Projective Transformations . . . 682
A.10.2 Affine Transformations via Projective Transformations . . . . 683 CONTENTS
A.11 Designer Projective Transformations . . . . . . . . . . . . . . . . . . . 685
xv
Preface
W
elcome to the third edition of Computer Graphics Through OpenGL:
From Theory to Experiments! The first edition appeared late 2010 and
the second four years after in 2014. Now, it’s been another four years in
which I received a lot of thoughtful and, happily, mostly positive feedback. I heard
from instructors, students, as well as individuals using the book for self-study. Their
observations together with my own classroom experience started me off a year ago
writing a new edition. It’s been a fairly intense past several months, most of my
waking hours spent sitting where I am now in front of the computer. But it’s been
fun too – being in communion with an imaginary reader who I am trying to enlighten
and keep engaged at the same time – and I am pleased with the result. I hope you
will be too. Let’s get to the facts.
Specs
This book comprises 21 chapters, an extended appendix on a fundamental math topic,
plus two more appendices containing a math self-test and its solutions. It comes with
approximately 180 programs, 270 experiments based on these programs, 750 exercises,
including theory and programming exercises, 110 worked examples, and 700 four-color
illustrations, include drawings and screenshots. An instructor’s manual containing
solutions to selected exercises is available from the publisher. The book was typeset
using LATEX and figures drawn in Adobe Illustrator.
Target Audience
Prerequisites
• Sample chapters, table of contents, preface, subject and program index, math
self-test and solutions at the Home page.
• Program source code, developed on a Windows 10 platform using the Microsoft
Visual Studio Community 2015 IDE and subsequently tested to run with MSVS
Community 2017, which should run on other versions of Windows/MSVS, as
well as Mac OS and Linux platforms. The programs are arranged chapter-wise
in the top-level folder ExperimenterSource at the Downloads page.
• Guide to installing OpenGL and running the programs on a Windows/MSVS
platform at the Downloads page.
• Multiplatform Experimenter software to run the experiments at the Downloads
page. Experimenter’s interface is Experimenter.pdf, a file containing all the
experiments from the book; except for those in Chapter 1, each is clickable
to bring up the related program and workspace. Experimenter is only an aid
and not mandatory – each program is stand-alone. However, it is the most
convenient way to run experiments in their book order.
• Book figures in jpg format arranged in sequence as one PowerPoint presentation
per chapter at the Instructor page.
• Instructor’s manual with solutions to 100 problems – instructors who have
adopted the textbook can submit a request at the Instructor page.
Pedagogical Approach
Code and theory have been intertwined as far as possible in what may be called a
theory-experiment-repeat loop: often, following a theoretical discussion, the reader is
asked to perform validating experiments (run code, that is); sometimes, too, the other
way around, an experiment is followed by an explanation of what is observed. It’s
kind of like discovering physics.
Why use an API?
Needless to say, I am not a fan of the API-agnostic approach to teaching CG, where
focus is on principles only, with no programming practice.
Undergrads, typically, love to code and make things happen, so there is little
justification to denying the new student the joy of creating scenes, movies and games,
not to mention the pride of achievement. And, why not leverage the way code and
theory reinforce one another when teaching the subject, or learning on one’s own,
when one can? Would you want Physics 101 without a lab section?
Moreover, OpenGL is very well-designed and the learning curve short enough to
fully integrate into a first CG course. And, it is supported on every OS platform with
drivers for almost every graphics card on the market; so, in fact, OpenGL is there to
use for anyone who cares to.
Note to student: Our pedagogical style means that for most parts of the book you
want a computer handy to run experiments. So, if you are going to snuggle up with it
at night, make it a threesome with a notebook.
Note to instructor : Lectures on most topics – both of the theory and programming
practice – are best based around the book’s experiments, as well as those you develop
yourself. The Experimenter resource makes this convenient. Slides other than the
plentiful book figures, the latter all available on-line, are rarely necessary.
How to teach modern shader-based OpenGL?
Our point of view needs careful explanation as it is different from some of our peers’.
Firstly, to push the physics analogy one more time, even though relativistic mechanics
seems to rule the universe, in the classroom one might prefer doing classical physics
before relativity theory. xix
Preface Shaders, which are the programmable parts of the modern OpenGL pipeline, add
great flexibility and power. But, so too, do they add a fair bit of complexity – even
a cursory comparison of our very first program square.cpp from Chapter 2 with
its equivalent in fourth-generation OpenGL, squareShaderized.cpp, complemented
with a vertex and a fragment shader in Chapter 15, should convince the reader of this.
Consider more carefully, say, a vertex shader. It must compute the position
coordinates of a vertex, taking into account all transformations, both modelview and
projection. However, in the classical fixed-function pipeline the user can simply issue
commands such as glTranslatef(), glFrustum(), etc., leaving to OpenGL actual
computation of the transformed coordinates; not so for the programmable pipeline,
where the reader must write herself all the needed matrix operations in the vertex
shader. We firmly believe that the new student is best served learning first how to
transform objects according to an understanding of simply how a scene comes together
physically (e.g., a ball falls to the ground, a robot arm bends at the elbow, etc.) with
the help of ready-to-use commands like glTranslatef(), and, only later, how to
define these transforms mathematically.
Such consideration applies as well to other automatic services of the fixed-function
pipeline which allow the student to focus on phenomena, disregarding initially
implementation. For example, as an instructor, I would much prefer to teach first how
diffuse light lends three-dimensionality, specular light highlights, and so on, gently
motivating Phong’s lighting equation, leaving OpenGL to grapple with its actual
implementation, which is exactly what we do in Chapter 11.
In fact, we find an understanding of the fixed-function pipeline makes the subsequent
learning of the programmable one significantly easier because it’s then clear exactly
what the shaders should try to accomplish. For example, following the fixed-function
groundwork in Chapter 11, writing shaders to implement Phong lighting, as we do in
Chapter 15, is near trivial.
We take a similarly laissez-faire attitude to classical OpenGL syntax. So long as it
eases the learning curve we’ll put up with it. Take for example the following snippet
from our very first program square.cpp:
glBegin(GL_POLYGON);
glVertex3f(20.0, 20.0, 0.0);
glVertex3f(80.0, 20.0, 0.0);
glVertex3f(80.0, 80.0, 0.0);
glVertex3f(20.0, 80.0, 0.0);
glEnd();
Does it not scream square – even though it’s immediate mode and uses the discarded
polygon primitive? So, we prefer this for our first lesson, avoiding thereby the
distraction of a vertex array and the call glDrawArrays(GL TRIANGLE STRIP, 0, 4),
as in the equivalent 4.x program squareShaderized.cpp, our goal being a simple
introduction of the synthetic-camera model.
With these thoughts in mind the book starts in Chapter 2 with classical pre-shader
OpenGL, progressing gradually deeper into the API, developing CG ideas in parallel,
in a so-called theory-experiment-repeat loop. So, what exactly is an experiment?
An experiment consists either of running a book program – each usually simple for
the purpose of elucidating a single idea – or attempting to modify one based on an
understanding of the theory in order, typically, to achieve a particular visual result.
By the end of Chapter 14 the student will have acquired proficiency in pre-shader
OpenGL, a perfectly good API in itself. As well, equally importantly, she will have
an understanding of CG principles and those underlying the OpenGL pipeline, which
will dramatically ease her way through the concepts and syntax of OpenGL 4.x, the
newest generation of the API, covered in Chapters 15-16.
Does this kind of introduction to modern OpenGL, via the old and, possibly,
obsolete, not ingrain bad habits? Not at all, from our experience. When push comes
xx to shove, how hard is it to replace polygons with triangle strips? Or, use vertex buffer
objects (VBOs) and vertex array objects (VAOs) to store data? Does our approach Preface
cost timewise? If the goal is OpenGL 4.x, then, yes, it does take somewhat longer,
but there are various possible learning sequences through the book and 4.x certainly
can be reached and covered in a semester.
In short, then, we believe the correct way to modern OpenGL is through the
classical version of the API because this allows the learning process to begin at
a high level, so that the student can concentrate on gaining an overall end-to-end
understanding of the CG pipeline first, leaving the OpenGL system to manage low-level
processes (i.e., those inside the pipeline like setting transformation and projection
matrices, defining fragment colors, and such). Once she has a high-level mastery,
subsequently “descending” into the pipeline to take charge of fixed-function parts in
order to program them instead will, in fact, be far less arduous than if she tried to do
both – learn the basics and program the pipeline – at the same time.
Another point to note in this context is that, as noted before, classical OpenGL is
a complete API in itself which, in fact, can be more convenient for certain applications
(e.g., it allows one access to the readymade GLUT objects like spheres and toruses).
There are, as well, thousands of currently live applications written in classical OpenGL,
which are not going go to be discarded or rewritten any time soon – the reason, in fact,
for the Khronos Group to retain the compatibility version of the API – so familiarity
with older syntax can be useful for the intending professional.
What about Vulkan?
We thought you might ask. Vulkan is the much-hyped “successor” to OpenGL. It is a
highly explicit API, taking the programmer close to the hardware and asking her to
specify almost all facets of the pipeline from end to end. Benefits of programming
near the hardware include thin drivers, reduced run-time overhead and the ability to
expose parallelism in the GPU. (Vulkan is not only a 3D graphics API, but used to
program GPU-heavy compute applications as well.)
However, Vulkan’s explicitness and consequent verbosity make it highly unsuitable
as an introductory CG API. Here are some program sizes to begin with. The first
OpenGL program in the book, square.cpp, which draws a black square on a white
background, is about 90 lines of code in pre-shader 2nd generation OpenGL; a
functionally equivalent program, squareShaderized.cpp, written in OpenGL 4.3
later on in the book is 190 lines plus 25 lines of shader code; a minimal equivalent
Vulkan program, squareVulkanized.cpp, written separately by the author is 1,100
lines (no, that’s no misprint – the reader will find the program at the Downloads page
of the book’s website) plus 30 lines of shader code. Figure 1 is a screenshot.
Moreover, explicitness requires a Vulkan programmer to be familiar with the
Figure 1: Screenshot of
functioning of the graphics pipeline at a low level in order to specify it, which almost squareVulkanized.cpp, a
instantly disqualifies it from being a beginner’s API. Further, delaying programming 1000+ line Vulkan
until after the pipeline has been covered goes utterly against our own pedagogical program.
approach which is to engage students with code the first day.
So, is OpenGL, or for that matter, this book, of any use for someone intending to
learn Vulkan? Well:
(a) The Vulkan graphics pipeline is essentially the same as OpenGL’s. Therefore,
learning OpenGL is progress toward Vulkan. Moreover, once a programmer has
mastered OpenGL, she has most of what’s needed to “take full charge” of the
pipeline, which is what Vulkan is all about.
(b) The runtime gains of Vulkan don’t begin to show up in any significant way
until one gets to complex scenes with lots of textures, objects and animation.
Less complicated applications - including, obviously, those in any introductory
CG book - benefit little performance-wise from being written (or, rewritten) in
Vulkan, not justifying the huge overhead in code.
This means that many OpenGL apps are going to stay that way and new ones
continue to be written. It’s a matter of knowing which tool to use: pre-shader xxi
Preface OpenGL, OpenGL 4.x, Vulkan, . . .. (Hooking up a U-Haul trailer to the back of
a Ferrari is never a good idea.)
Nevertheless, if you are of the Vulkan or bust frame of mind then the advice we would
have is to study this book up to Chapter 16, when you will have a solid understanding
of fourth-generation OpenGL, then pick up, say, the canonical Vulkan guide [131],
through which you should then be able to make quick progress.
Chapter 1 Chapter 2
An Invitation On to OpenGL
to Computer and 3D Computer
Graphics Graphics
Chapter 9
Orientation
Chapter 10
Modeling in
3D Space
Chapter 15
OpenGL 4.3,
Shaders ... :
Liftoff
Chapter 16
OpenGL 4.3,
Shaders ... :
Escape Velocity
xxiv
Suggested Course Outlines Preface
See the chapter dependencies in Figure 2.
(1) Undergraduate one-semester first CG course:
This course should be based on Chapters 1-16, though full coverage might be
ambitious for one semester. Instructors may pick topics to emphasize or skip,
depending on their goals for the course and the chapter dependence chart.
For example, for more practice and less theory, a possible sequence would be 1 →
2 → 3 → 4 → 6 (only frustum culling) → 7 → 8 → 9 → 10 (skip curve/surface
theory) → 11 → 12 → 13 → 15 → 16.
Even this abbreviated sequence may be hard to pack into one semester. Please
keep in mind that when choosing what to write about the author preferred to
err on the side of excess rather than less. So, almost always will the instructor
find more material in a chapter than she cares to teach – we leave her to pick
her way out.
The most effective teaching method with this book is to base discussion around
experiments – both from the book and those the instructor develops herself.
Our Experimenter software makes this especially convenient. Students should be
involved in the experiments, running code simultaneously on their own machines
in class. Use of slides should be minimized except, possibly, for the plentiful
book figures, which are available to download, arranged as one PowerPoint
presentation per chapter.
(2) Advanced CG courses:
This book could serve as a reference for a study of 3D design – particularly,
Bézier (Chapter 17), B-spline (Chapter 18) and rational Bézier and NURBS
theory (Chapter 20) – and of projective transformations and their applications
(Appendix A and Chapter 20). From a practical point of view, Chapters 15-16
go fairly deep into the fourth generation of OpenGL and the GLSL, useful for
students who may be familiar with only the classical pipeline.
(3) Self-study:
A recommended first pass would be 1 → 2 → 3 → 4 → 7 → 8 → 9 (go light on
7-9 if your math is rusty) → 10 (skip theory) → 11 → 12 → 13 → 15 → 16.
Following this the student should take up a fair-sized programming project,
returning to the book as needed. For the theoretically-inclined there’s a lot to
keep her busy in Chapters 5 and 17-21.
Acknowledgments
I owe a lot to many people, most of all students whom I have had the privilege of
teaching in my CG classes over the years at UW-Milwaukee and then the Asian
Institute of Technology.
I thank KV, Ichiro Suzuki, Glenn Wardius, Mahesh Kumar, Le Phu Binh, Maria
Sell and, especially, Paul McNally, for their support at UWM, where I began to teach
CG and learn OpenGL.
I am grateful to my colleagues and the staff and students at AIT for such a pleasant
environment, which allowed me to combine teaching and research commitments with
the writing of a book.
Particular thanks at AIT to Vu Dinh Van, Nguyen Duc Cong Song, Ahmed
Waliullah Kazi, Hameedullah Kazi, Long Hoang, Songphon Klabwong, Robin Chanda,
Sutipong Kiatpanichgij, Samitha Kumara, Somchok Sakjiraphong, Pyae Phyo Myint
Soe, Adbulrahman Otman, Sushanta Paudyal, Akila de Silva, Nitchanun Saksinchai,
Thee Thet Zun, Suwanna Xanthavanij, Visutr Boonnateephisit, Matt Dailey, and our
ever-helpful secretaries K. Siriporn and K. Tong. xxv
Preface I am grateful to Kumpee Teeravech, Kanit Tangkathach, Thanapoom Veeranitinun,
Pongpon Nilaphruek, and Wuttinan Sereethavekul, students of my CG course at AIT,
for allowing me to use programs they wrote.
I owe an enormous debt of gratitude to my former student Chansophea Chuon for
hundreds of hours of help with the first edition, which got this book off the ground in
the first place. I thank Somying Pongpimol for her brilliant Illustrator drawings. She
drew several of the figures based on my rather amateurish original Xfig sketches. I
would like to thank Olivier Nicole for help with the book’s website.
I am especially grateful to Brian Barsky for encouraging me to persevere after
seeing an early and awkward draft of the first edition, and subsequently inviting the
finished product to the series he was then editing. Relatedly, I thank my neighbor
Doug Cooper two floors down for putting me in touch with Brian at the time Brian
was scouting prospective authors.
I want to acknowledge the production team at Taylor & Francis who went out of
their way for this book. Particularly, I want to thank my editor Randi Cohen who is
as professional and efficient as she is pleasant to deal with.
I am grateful to readers of the first and second editions, as well as reviewers
who looked over drafts and proposals, whose comments led, hopefully, to significant
improvements.
I have nothing but praise for the DJs and kindly staff of the Mixx nightclub in
downtown Bangkok whose dance floor provided a much-needed sanctuary for me to
blow off steam after long hours on the computer.
I acknowledge the many persons and businesses who were kind enough to allow
me to include images to which they own copyrights.
On a personal note, I express my deep gratitude to Dr. Anupam De for keeping
Kamaladi healthy enough that I could concentrate on the first edition through the
few years that I spent writing it.
Finally, I must say that had I not had the opportunity to study computer science
in the United States and teach there, I would never have reached a position where I
could even contemplate writing a textbook. It’s true, too, that had I not moved to
Thailand, this book would never have begun to be written. This is an enchanting
country with a strangely liberating and lightening effect – to which thousands of
expats can attest – that encourages one to express oneself.
xxvi
About the Author
Sumanta Guha earned a Ph.D. in mathematics from the Indian Statistical Institute,
Kolkata, in 1987. From 1984 to 1987 he taught mathematics at Jadavpur University
in Kolkata. He left in 1987 to study computer science at the University of Michigan
in Ann Arbor, where he earned a Ph.D. in 1991. On graduating from Michigan he
joined the Electrical Engineering and Computer Science faculty of the University of
Wisconsin-Milwaukee where he taught from 1991 to 2002. In 2002 he moved to the
Computer Science and Information Management program of the Asian Institute of
Technology in Thailand, where he is currently an adjunct professor. His research
interests include computational geometry, computer graphics, computational topology,
robotics and data mining.
xxvii
Other documents randomly have
different content
THE FULL PROJECT GUTENBERG LICENSE
PLEASE READ THIS BEFORE YOU DISTRIBUTE OR USE THIS WORK
1.D. The copyright laws of the place where you are located also
govern what you can do with this work. Copyright laws in most
countries are in a constant state of change. If you are outside the
United States, check the laws of your country in addition to the
terms of this agreement before downloading, copying, displaying,
performing, distributing or creating derivative works based on this
work or any other Project Gutenberg™ work. The Foundation makes
no representations concerning the copyright status of any work in
any country other than the United States.
1.E.6. You may convert to and distribute this work in any binary,
compressed, marked up, nonproprietary or proprietary form,
including any word processing or hypertext form. However, if you
provide access to or distribute copies of a Project Gutenberg™ work
in a format other than “Plain Vanilla ASCII” or other format used in
the official version posted on the official Project Gutenberg™ website
(www.gutenberg.org), you must, at no additional cost, fee or
expense to the user, provide a copy, a means of exporting a copy, or
a means of obtaining a copy upon request, of the work in its original
“Plain Vanilla ASCII” or other form. Any alternate format must
include the full Project Gutenberg™ License as specified in
paragraph 1.E.1.
• You pay a royalty fee of 20% of the gross profits you derive
from the use of Project Gutenberg™ works calculated using the
method you already use to calculate your applicable taxes. The
fee is owed to the owner of the Project Gutenberg™ trademark,
but he has agreed to donate royalties under this paragraph to
the Project Gutenberg Literary Archive Foundation. Royalty
payments must be paid within 60 days following each date on
which you prepare (or are legally required to prepare) your
periodic tax returns. Royalty payments should be clearly marked
as such and sent to the Project Gutenberg Literary Archive
Foundation at the address specified in Section 4, “Information
about donations to the Project Gutenberg Literary Archive
Foundation.”
• You comply with all other terms of this agreement for free
distribution of Project Gutenberg™ works.
1.F.
1.F.4. Except for the limited right of replacement or refund set forth
in paragraph 1.F.3, this work is provided to you ‘AS-IS’, WITH NO
OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO WARRANTIES OF
MERCHANTABILITY OR FITNESS FOR ANY PURPOSE.
Please check the Project Gutenberg web pages for current donation
methods and addresses. Donations are accepted in a number of
other ways including checks, online payments and credit card
donations. To donate, please visit: www.gutenberg.org/donate.
Most people start at our website which has the main PG search
facility: www.gutenberg.org.
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
textbookfull.com