CS代考 SCI 351-2:Intermediate Computer Graphics

COMP_SCI 351-2:Intermediate Computer Graphics
Syllabus: Winter 2023 (Jan-Mar)
Updated: 1/3/2023 11:31 AM

Course Description:
Second in a 3-course set surveying methods and theory of computer graphics
COMP_SCI 351-1: Introduction to Computer Graphics: 3D Basics, WebGL, GLSL Shaders
COMP_SCI 351- 2: Intermediate Computer Graphics: Particles, Soft Things, &

COMP_SCI 331: Intro to Computational Photography: 4D Ray space, HDR, Coded Apertures, etc.

351-2 Prerequisites:
COMP_SCI 214 (was 311) Data Structures or equivalent (or graduate student standing: MS or PhD)
COMP_SCI 351-1 Introduction to Computer Graphics (or instructor’s OK; please ask if unsure)

CS 351-2 is an intermediate but in-depth course on computer graphics principles for engineers and scientists
that builds directly on CS 351-1. As before, you won’t learn how to use graphics packages (Blender, Maya,
RenderMan, Unity, Unreal, or even “three.js”) because you can just read manuals for that. Instead, you will
learn what’s inside them, how it’s computed, and why; you learn enough to write new graphics programs, ones
with features not available in a commercial product. We use the most universally available 3D graphical API
spec (OpenGL / WebGL) for easy web browser-based access to the graphics acceleration hardware in almost all
computerized devices (from supercomputers to cell phones), and the GLSL shading language — programmable
shading by parallel programming (Microsoft-proprietary DirectX & HLSL are similar).

CS351-2 is a project-oriented course: reading and lecture materials are important, but for a deeper and more
genuine understanding of computer graphics methods you must write some serious code to make several
detailed interactive programs of your own. Step-by-step, week-by-week, you will build on your WebGL
knowledge from CS351-1 to construct two large, elaborate programming projects:

• Project A: Particles and Movement: Build an extensible system for making multiple dynamic interactive
particle systems that move by constrained numerical integration. First, we learn how to make swirling
free-form shapes from force-driven clouds of independent particles (fireworks, swarms of birds, rain,
snow, fog, blowing leaves, etc.). Next, we form coupled sets of constrained particles to simulate 1D, 2D,
and 3D soft structures (rope, cloth, rubbery solids; fluids, splashing, fog, smoke etc.). All will use the
same vectorized, state-space formulation for easy implementation of broad classes of ‘explicit’ and
‘implicit’ solvers. These extensible solvers enable your particles to move in a stable manner for accurate
and realistic physical simulations.

• Project B: Light Done Right: Write a general-purpose recursive ray-tracer in an extendable schema that
includes an interactive WebGL previewer for 3D scene setup. Your floating-point ray-tracer can easily
support physically accurate lighting, antialiasing, shadows, multiple reflections and transparency. You
can extend it to explore implicit surfaces, procedural textures and materials, BRDFs and light
measurements, extended light sources (soft shadows), stochastic sampling and basic global illumination

• Participation Points: Unscheduled/random attendance; tasks begun in class; one-question pop-quizzes
on assigned readings, and varied project check-points to ensure you don’t get too far behind.

If you wish, you can use your Project B tracer to make beautifully rendered movies of Project A results.

Course Grading Method:
No midterms, no final exam. Programming Projects: 2 x 45% (Caution! Late Penalties!)
Participation Points: 10 x 1% (Caution! Some are same-day!)

https://www.mccormick.northwestern.edu/computer-science/academics/courses/descriptions/351-1.html
https://www.mccormick.northwestern.edu/computer-science/academics/courses/descriptions/351-2.html
https://www.mccormick.northwestern.edu/computer-science/academics/courses/descriptions/331.html

Class Meetings:
MWF 1:00-1:50PM,) Room G-15 Annenberg Hall (McCormick now REQUIRES in-person attendance)

Instructor: , Northwestern Univ.
Office: , Room 3.221 (center of middle east-west hallway)

Contact: For any questions on course materials or programs, just ask during class; all will benefit.

I’m always available after class too; If you’re not, post questions on CANVAS Discussion Board.

For private matters:

Office: (847) 467-2129 URGENT? cellphone: (847) 702-9057

Office hours: 2:00pm onwards after every class meeting, or by appointment (ZOOM) – send e-mail.

TAs & Graders: Jipeng Sun (see CANVAS for office hours),
(See CANVAS for office hours),

Textbooks (Required):
• “Foundations of Physically-Based Modeling and Animation” © 2017, House and Keyser;

AK Peters / CRC Press. Note: widely available online; hard-copy or e-book —search for it!

1st of 3 in his Ray-Tracing Mini-Book Series — all are great — $3 each on Amazon/Kindle.

Other Good Resources (Recommended, but NOT required)
• “WebGL Programming Guide: Interactive 3D Graphics Programming with WebGL” (CS 351-1 text)

or E-book (e.g. Kindle) – either is OK)

• “Mathematics for 3D Game Programming and Computer Graphics” (3rd Edition or later)

(Paperback or -Book – either is OK). This was also an optional text for COMP_SCI 351-1.

• “Physically-Based Rendering” , , , (free online).

• “OpenGL Shading Language” (3rd Edition or later: the “Orange Book”) encyclopaedic, authoritative guide to

programmable shading in OpenGL and WebGL using GLSL; complete architectural guide.

• “OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3”

(8th Edition or later, the “Red Book”), By Dave Shreiner, , . Kessenich, . Licea-Kane.

Course Organization:
This course covers a large volume of fairly easy-to-grasp but intricate-to-implement material organized into only 2 major

projects plus informal ‘participation activities’ we do or begin in class. Starter code helps advance fairly rapidly through a

series of ideas that might otherwise force a radical re-organization of naïve code.

Waiting until the last few days is fatal in this class. These two projects set 90% of your grade: don’t get caught in a

desperate last-minute scramble! To actively discourage procrastination, I will periodically (about once a week) require

you to complete a crucial intermediate step in your code and submit it on CANVAS as a graded ‘activity’.

I do my best to put all useful course materials on CANVAS and give quick help on CampusWire, but these alone are never

enough. Please ATTEND the class meetings (or watch the recordings: you can set ‘playback speed’ to as high as 2X);

https://maps.northwestern.edu/txt/facility/86

https://www.crcpress.com/Foundations-of-Physically-Based-Modeling-and-Animation/House-Keyser/p/book/9781482234602
https://www.crcpress.com/Foundations-of-Physically-Based-Modeling-and-Animation/House-Keyser/p/book/9781482234602

https://sites.google.com/site/webglbook/
https://www.pbrt.org/
https://www.routledge.com/Fluid-Simulation-for-Computer-Graphics/Bridson/p/book/9781482232837

without them you may miss graded ‘activities’, vital concepts and explanations, important software structure, debug

strategies, and personalized help with your project.

Project Organization:
CANVAS pages describe each project’s requirements & grading method, guided by:

• ‘Assignment Sheet’ (a PDF file) with all project details and expectations, and a

• ‘Grading Sheet’ (a PDF file) that holds the Project’s entire and exact grading rubric
(lists points earned for each implemented feature) used for Demo Day and Project final grading.

• All projects are individual in this course – no project teams in 351-2.

We follow a 2-step Demo-and-Grading process:

First, on Demo Day everyone demonstrates their initial ‘completed’ program to others in-person. We exchange advice

and mark ‘grading sheets’ for each other. Demo Day is often fun and inspiring, as everyone sees and learns other

graphical ideas and new ways to further improve their projects. Class attendance is vital on Demo Day!

You then have a few more days to make improvements, corrections and final revisions to your Project.

Second, everyone submits their Finalized Project on CANVAS for grading by instructor & TAs.

• Every project is graded on a 100-point scale.

• To earn 100 points, complete all Project requirements flawlessly, and participate in Demo Day.

• To earn more points, add some ‘extra-credit’ features to your project from those listed on ‘Grading Sheet’.
LATE PENALTIES:

• You EARN some points when attend Demo Day. Show something that works – even if it’s not very different
from the starter code – we must have some of your work to discuss/improve it!

• You lose 10pts per day if you turn in your Final Project for grading after the deadline
e.g. if you turn in your work 3 days late, we subtract 30 points from your score.

Each project requires multiple files and folders, so

to turn in the final version of your Project,

a) Don’t use spaces or any non-alphanumeric chars in your file/folder names (stay POSIX compliant)

b) arrange all project files and folders into one carefully-named directory:

FamilynamePersonalname_ProjA

For example, my project B folder name would be: TumblinJack_ProjB

c) Make sure your named project file is complete. Include all sub-directories (e.g. ‘lib’) with all other files

needed to run your program.

HINT: copy final project directory to your desktop. If it does not run, look for missing files or filenames…

d) Include your projects’ written report as a PDF file in this directory: (e.g. TumblinJack_ProjB.pdf)

e) make a ‘ZIP’ file (or a “compressed folder” – please, no .rar or .tar files!) from your project directory/folder,

and use the same name. For example, my ZIP file name would be TumblinJack_ProjB.zip.

(When I download your ZIP file and ‘extract’ or ‘uncompress’ it, I should be able to easily find your

report, find your HTML file, drag it to a browser and see your program working flawlessly onscreen.

f) Submit your work by CANVAS upload (not by email). I always grade the most-recently submitted version.

Please do start early,

please do explore the web and

please do share hints and ideas on CampusWire to solve problems and improve results.

But, of course, don’t share code with other students, and don’t plagiarize or copy anyone else’s code; each of you must

write your own original work. Let’s not repeat any plagiarism tragedies: if you can find 351 project code from others on

GitHub, then so can I; ‘MOSS’ will flag it and I’m then required to report it to the Dean for investigation.

https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.4.0/com.ibm.zos.v2r4.bpxa400/bpxug469.htm

Outside Sources & Plagiarism Rules:
Simple: never submit the uncredited work of others as your own. You are welcome to use any of the ‘starter
code’ I supply to you on CANVAS without citing its source, and to modify it freely. However, these must be YOUR

modifications; never add uncredited modifications made by others – cite the source & person(s) who made it better!

I want you to explore — learn from websites, tutorials and friends anywhere (e.g. StackOverflow, MDN,

CodeAcademy, OpenGL.org, WebGLfundamentals.org, even GitHub (but DON’T COPY!) ), to spur you to always seek

better ideas. Share what you find with other students, too — list the URLs on Piazza, etc. as comments to give the

sources that helped you write your code. But ALWAYS credit the works of others—no plagiarism!

Plagiarism rules for writing essays apply equally well to writing software. You would never cut-and-paste whole

paragraphs and passages written by others unless it’s a clearly marked quote with cited sources. The same is true for

whole functions, blocks of statements, and scripts written by others. Never copy others’ work without crediting them,

and never try to disguise it by rearrangement and renaming (MOSS won’t be fooled). Instead, read their code, learn their

best ideas and methods, and then delete the file and/or close the webpage. That’s right; stop looking at it!

Copy nothing – learn the idea, then write your own code unassisted, in your own style explained in your own words.

Be sure to add a gracious comment to your code that gives the credit and the source of those good ideas.

Also, please note that I apply the ‘MOSS’ or other kinds of anti-plagiarism software on graded assignments:

https://theory.stanford.edu/~aiken/moss/

(If I find any plagiarism evidence (sigh), the University requires me to report it to the Dean of Students for investigation.

It’s a defeat for all involved: they’re very strict and very punitive. Some students were badly shamed in previous years.

SCHEDULE: (Jan 3 – Mar 17)

Required Textbooks:

WGL == WebGL Programming Guide Kouichi Matsuda, 1st Ed.

AK Peters / CRC Press. Note: available as hard-cover or as dition: $56 for either.

Additional Texts (excerpts posted on CANVAS as PDFs):

Week Read Topics

(+ starter

A1: Ballistic Balls & Bouncy Walls MONDAY Jan 9: last day to add another class

Administrivia, Overview, Demos, Math Review.

–Force-driven particles: F=mA; gravity, simple drag, sliding limits, axis-aligned 2D wall collisions.

–Forces from Vector Fields: earth gravity; dust tornados, force-field ‘construction set’,

–Forces from other particles? springs? planetary motion? Charge? pressure?→Force-maker

(+ starter

A2: Forced Movement & Integration: B4Wed Goal: 3D ball-fountain in MKS units

–State-Space Formalism: particle set, forcers, constraints, solvers.

— Forces between particles; force-makers (gravity, wind, flocking, springs, charge, magnetism),

— Good Fast Explicit Solvers: Euler and Mid-point (obvious, simple, but easily & often unstable)

— Why velocity-drag helps stability (orbital examples) and looks plausible

https://theory.stanford.edu/~aiken/moss/

A3: Softness: Coupled Particles B4Tues Goal: First spring/mass pair

**** Mon Jan 16: . Day (no classes) ****

— Fixed Spring-Mass networks (e.g. rope, cloth, skin, solids…)

— hard constraints & their difficulties: ropes, rods, floor/wall contact

–Implicit & Semi-Implicit Solvers (not so obvious, but stable and extendable), Verlet Method

–Solid-Body Rotations; increasing the ‘speed of sound’ in large systems of particles

Chap 10-11

(OPTIONAL:

Chap 9, 12-

A4: Hardness: Simple Rigid Constraints B4Tues Goal: Stable Implicit integrators

— Angular velocity & acceleration math

— Intro to collision detection

— (if time permits: Fluid basics: Navier-Stokes, spatial data structs and simplified solutions)

— Review Day/Help Session…

Project A!

B1: Ray-Tracing Basics: How to Measure Light + Grid-plane with fixed camera

**** Wed Feb 01 DEMO DAY**** Show us your cool live particles!

— INTRO: Why trace rays? How can we measure light along a ray? (ANS: ‘radiance’; WEIRD units!)

–Light rays & materials: wavelength, power, irradiance, radiance, incidence, exitance; BRDF, scatter

–(Tues Feb 8: Proj A final version due)

slides only)

B2: Trace Rays to Shapes: ****(Drop Day: Friday Feb 10)****

–Rays, Cameras & a ‘LineGrid’ plane. B4Tues Goal: Matched WebGL/Ray cameras + grid

–Anti-Aliasing by Jittered Super-sampling

–Model Matrix and SceneGraphs for Ray-tracing; transform the ray, not the object (!), by

INVERSE of webGL / Scene Graph. What happened to the surface-normal matrix?

Slides only)

B3: Ray-Hits and Non-Trivial Surfaces: B4Tues Goal: Gray Sphere + cube

–How to organize your ray-tracer; vital data structures; starter code explorations.

— Tests for more shapes: Plane → cube? Cylinder? Sphere? The FASTEST sphere-hit finder.

–(Discussed but not implemented: Octrees, Quadtrees, BSP, spheretrees, other spatial data structs)

–Sphere-marching: Blobbies/MetaBalls and other implicits; root-finding and binary-search solvers

B4: Hard Shadows & , B4Tues Goal: hard shadows + Phong-lit Spheres

–Sky Box sets colors for rays that ‘miss’; ****(Spring Registration begins Feb 20)****

–Hard shadows: shadow rays, normals, and more from our rayShade() function

–old and new shading models: Phong, Cook-Torrance, LaFortune, He, Ward, etc.

–Stochastic sampling of the sky-box for ‘soft’ shadows (see ’s ‘RT1W’ reading)

B5: Recursion, Mirrors, Glass, Texture and How to Go further… (

— Recursion from mirror Reflection; how to combine with specular highlights;

–Snell’s Law, refraction and extinction in transparent materials

–3D Procedural textures: checkerboards, /turbulence

–Constructive Solid Geometry (CSG): how a HitList lets you make lenses and drill holes in spheres…

–Photo-texture; photo-based sky-box (e.g. cube maps or ‘environment maps’)

Mon, Fri: Review Day / Help Session

****Wed Mar 08 DEMO DAY**** show us your cool pictures! (next-to-last day of classes)

–(Mon Mar 13 – (day 1 of exam week): Proj B final version due)

——————————————————————

HISTORIC FUN: The Utah Teapot — Crow, F., “The origins of the teapot”, IEEE Computer aphics and Applications, January, 1987.

GENETIC ALGORITHMS FOR GRAPHICAL BEAUTY: interview; physical simulations guide ‘evolution’ of creatures

Sims, Karl, “Artificial evolution for computer graphics”, Computer Graphics, Vol. 25, No. 4, July, 1991.

FORMAL LANGUAGES FOR BOTANY: Oppenheimer, P.E., Real time design and animation of fractal plants and trees”, Computer

Graphics, Vol. 20, No. 4, August, 1986. “Dr. P” http://algorithmicbotany.org/papers/ Recent intro/tutorial video (4 minutes); (23

minutes). See especially his ground-breaking book on L-systems, now freely downloadable (Ctrl-F ‘beauty of Plants’)

https://en.wikipedia.org/wiki/Utah_teapot

https://en.wikipedia.org/wiki/Karl_Sims
http://algorithmicbotany.org/papers/

https://youtu

程序代写 CS代考加微信: powcoder QQ: 1823890830 Email: powcoder@163.com

Related Posts