Processing语言入门指南：从图像到互动的编程秘籍

需积分: 10 98 浏览量更新于2024-07-21 收藏 7.81MB PDF 举报

《Learning Processing》是一本由"The Nature of Code"系列作者编写的入门指南，专注于Processing语言的介绍。Processing是一种直观且易于理解的编程语言，特别适合初学者接触计算机图形学、图像处理、动画和交互设计。这本书以其简洁的语法和幽默诙谐的风格，帮助读者快速上手，掌握如何利用Processing进行编程。 Processing的特点在于其结合了艺术与编程的元素，让初学者能够通过简单的命令实现复杂的视觉效果。书中内容涵盖了基础编程概念，如变量、数据类型、控制结构等，同时也深入讲解了如何运用Processing进行图像处理，如滤波、变换、合成等，这对于多媒体创作和交互设计具有重要意义。对于动画制作，作者会引导读者如何编写代码来创建动态画面，包括运动路径、帧率控制和事件驱动的交互。此外，书中还探讨了如何在Processing中实现互动，让程序响应用户的输入，增强了用户体验。除了基本技术，书中还可能涉及到一些高级主题，如数字模型的外观模拟、移动3D图形编程（使用OpenGLES和M3G）、医学可视化、几何代数在计算机科学中的应用，以及高动态范围成像的数据处理和显示技术。这些内容拓宽了读者的知识视野，使他们能够在更广阔的领域运用Processing。对于想要深入学习Maya的用户，书中也提供了《Complete Maya Programming Volume II》，介绍了Maya的3D建模和动画基础，以及针对Maya动画师的Mel脚本编程。同时，《MEL Scripting for Maya Animators》则是针对Maya动画的进一步深入教程。对于图形编程爱好者，还有《Advanced Graphics Programming Using OpenGL》一书，使用OpenGL进行高级图形编程，展示了更复杂的技术，如光照、纹理映射和渲染管线等。《Learning Processing》是一本实用且全面的教程，不仅适合初学者快速入门，也适合有一定基础的开发者深化对Processing语言的理解，并将其应用于实际项目中，无论是艺术创作还是技术开发都能从中获益良多。

xiv Introduction

Will this be on the test?

A book will only take you so far.  e real key is practice, practice, practice. Pretend you are 10 years old

and taking violin lessons. Your teacher would tell you to practice every day. And that would seem perfectly

reasonable to you. Do the exercises in this book. Practice every day if you can.

Sometimes when you are learning, it can be diﬃ cult to come up with your own ideas.  ese exercises are

there so that you do not have to. However, if you have an idea for something you want to develop, you

should feel free to twist and tweak the exercises to ﬁ t with what you are doing.

A lot of the exercises are tiny little drills that can be answered in a few minutes. Some are a bit harder

and might require up to an hour. Along the way, however, it is good to stop and work on a project that

takes longer, a few hours, a day, or a week. As I just mentioned, this is what the “ lesson ” structure is for.

I suggest that in between each lesson, you take a break from reading and work on making something in

Processing . A page with project suggestions is provided for each lesson.

All of the answers to all of the exercises can be found on this book’s web site. Speaking of which …

Do you have a web site?

 e Web site for this book is: http://www.learningprocessing.com

 ere you will ﬁ nd the following things:

• Answers to all exercises in the book.

• Downloadable versions of all code in the book.

• Online versions of the examples (that can be put online) in the book.

• Corrections of any errors in the book.

• Additional tips and tutorials beyond material in the book.

• Questions and comments page.

Since many of the examples in this book use color and are animated, the black and white, static

screenshots provided in the pages here will not give you the whole picture. As you are reading, you can

refer to the web site to view the examples running in your browser as well as download them to run

locally on your computer.

Week 7 Lesson 6: Chapter 13–14

Week 8 Lesson 7: Chapter 15–16

Week 9 Lesson 8: Chapters 17–19

Week 10 Lesson 9: Chapters 20–21

Week 11 Lesson 10: Chapters 22–23

Week 12 Final Project Workshop

Week 13 Final Project Workshop

Week 14 Final Project Presentations

Introduction xv

 is book’s web site is not a substitute for the amazing resource that is the oﬃ cial Processing web site:

http://www.processing.org .  ere, you will ﬁ nd the Processing reference, many more examples, and a lively

forum.

Take It One Step at a Time

 e Philosophy of Incremental Development

 ere is one more thing we should discuss before we embark on this journey together. It is an important

driving force behind the way I learned to program and will contribute greatly to the style of this book.

As coined by a former professor of mine, it is called the “ philosophy of incremental development. ” Or

perhaps, more simply, the “ one-step-at-a-time approach. ”

Whether you are a total novice or a coder with years of experience, with any programming project, it is

crucial not to fall into the trap of trying to do too much all at once. Your dream might be to create the

uber- Processing program that, say, uses Perlin noise to procedurally generate textures for 3D vertex shapes

that evolve via the artiﬁ cial intelligence of a neural network that crawls the web mining for today’s news

stories, displaying the text of these stories onscreen in colors taken from a live video feed of a viewer in

front of the screen who can control the interface with live microphone input by singing.

 ere is nothing wrong with having grand visions, but the most important favor you can do for yourself

is to learn how to break those visions into small parts and attack each piece slowly, one at a time.  e

previous example is a bit silly; nevertheless, if you were to sit down and attempt to program its features all

at once, I am pretty sure you would end up using a cold compress to treat your pounding headache.

To demonstrate, let’s simplify and say that you aspire to program the game Space Invaders (see: http://

en.wikipedia.org/wiki/Space_Invaders ). While this is not explicitly a game programming book, the skills to

accomplish this goal will be found here. Following our newfound philosophy, however, we know we need

to develop one step at a time, breaking down the problem of programming Space Invaders into small

parts. Here is a quick attempt:

1. Program the spaceship.

2. Program the invaders.

3. Program the scoring system.

Great, we divided our program into three steps! Nevertheless, we are not at all ﬁ nished.  e key is to

divide the problem into the smallest pieces possible, to the point of absurdity, if necessary. You will learn

to scale back into larger chunks when the time comes, but for now, the pieces should be so small that

they seem ridiculously oversimpliﬁ ed. After all, if the idea of developing a complex game such as Space

Invaders seems overwhelming, this feeling will go away if you leave yourself with a list of steps to follow,

each one simple and easy.

With that in mind, let’s try a little harder, breaking Step 1 from above down into smaller parts.  e idea

here is that you would write six programs, the ﬁ rst being the simplest: display a triangle . With each step,

we add a small improvement: move the triangle. As the program gets more and more advanced, eventually

we will be ﬁ nished.

xvi Introduction

1.1 Draw a triangle onscreen.  e triangle will be our spaceship.

1.2 Position the triangle at the bottom of the screen.

1.3 Position the triangle slightly to the right of where it was before.

1.4 Animate the triangle so that it moves from position left to right.

1.5 Animate the triangle from left to right only when the right-arrow key is pressed.

1.6 Animate the triangle right to left when the left-arrow key is pressed.

Of course, this is only a small fraction of all of the steps we need for a full Space Invaders game, but

it demonstrates a vital way of thinking.  e beneﬁ ts of this approach are not simply that it makes

programming easier (which it does), but that it also makes “ debugging ” easier.

Debugging

refers to the process of ﬁ nding defects in a computer program and ﬁ xing them so that the

program behaves properly. You have probably heard about bugs in, say, the Windows operating system:

miniscule, arcane errors deep in the code. For us, a bug is a much simpler concept: a mistake. Each time

you try to program something, it is very likely that something will not work as you expected, if at all. So

if you start out trying to program everything all at once, it will be very hard to ﬁ nd these bugs.  e one-

step-at-a-time methodology, however, allows you to tackle these mistakes one at a time, squishing the

bugs.

In addition, incremental development lends itself really well to object-oriented programming , a core

principle of this book. Objects, which will be introduced in Lesson 3, Chapter 8, will help us to develop

projects in modular pieces as well as provide an excellent means for organizing (and sharing) code.

Reusability will also be key. For example, if you have programmed a spaceship for Space Invaders and

want to start working on asteroids, you can grab the parts you need (i.e., the moving spaceship code), and

develop the new pieces around them.

Algorithms

When all is said and done, computer programming is all about writing algorithms . An algorithm is

a sequential list of instructions that solves a particular problem. And the philosophy of incremental

development (which is essentially an algorithm for you, the human being, to follow) is designed to make

it easier for you to write an algorithm that implements your idea.

As an exercise, before you get to Chapter 1, try writing an algorithm for something you do on a daily

basis, such as brushing your teeth. Make sure the instructions seem comically simple (as in “ Move the

toothbrush one centimeter to the left ” ).

Imagine that you had to provide instructions on how to accomplish this task to someone entirely

unfamiliar with toothbrushes, toothpaste, and teeth.  at is how it is to write a program. A computer is

nothing more than a machine that is brilliant at following precise instructions, but knows nothing about

the world at large. And this is where we begin our journey, our story, our new life as a programmer. We

begin with learning how to talk to our friend, the computer.

 e term “ debugging ” comes from the apocryphal story of a moth getting stuck in the relay circuits of one of computer scientist

Grace Murray Hopper’s computers.

剩余472页未读，继续阅读

qingfengzs

粉丝: 2
资源: 1

Processing语言入门指南：从图像到互动的编程秘籍

Learning Processing (English Edition)

Learning Processing-Daniel Shiffman

Learning Processing A Beginner's Guide to Programming Images, Animation 2nd

Achronix - Machine Learning Processing震惊！FPGA运算单元可支持高算力浮点

《Learning Processing》：零基础入门Processing编程与图像处理指南

Learning Image Processing with OpenCV

Learning Image Processing with OpenCV epub

Learning Image Processing with OpenCV.pdf

Learning Image Processing with OpenCV 无水印原版pdf

Learning Image Processing with OpenCV pdf + code

最新资源