Shiffman Daniel. Learning processing
Подождите немного. Документ загружается.
402 Learning Processing
void draw() {
// Begin making the PDF
if (recordPDF) {
beginRaw(PDF, " 3D.pdf " );
}
background(255);
stroke(0);
noFill();
translate(width/2,height/2);
rotateX(xTheta);
rotateY(yTheta);
box(100);
xTheta + = 0.02;
yTheta + = 0.03;
// End making the PDF
if (recordPDF) {
endRaw();
recordPDF = false;
}
}
// Make the PDF when the mouse is pressed
void mousePressed() {
recordPDF = true;
}
Two important notes about the PDF library.
• Images —If you are displaying images in the PDF, these will not necessarily look good after export.
A 320 240 pixel image is still a 320 240 pixel image whether rendered into a high-resolution
PDF or not.
• Te x t —If you are displaying text in the PDF, you will have to have the font installed in order to view
the PDF properly. One way around this is to include “ textMode(SHAPE); ” after size( ) . This will
render the text as a shape to the PDF and not require the font installed.
For full documentation of the PDF library, visit the Processing reference page at http://processing.org/
reference/libraries/pdf/index.html . While the PDF library will take care of many of your needs related
to high-resolution generation, there are two other contributed libraries that might be of interest. One
is proSVG by Christian Riekoff for exporting fi les in the SVG ( “ Scalable Vector Graphics ” ) format:
http://www.texone.org/prosvg/ . Another is SimplePostScript by Marius Watz for writing vector fi les in the
PostScript format: http://processing.unlekker.net/SimplePostscript/ .
Exercise 21-2: Create a PDF from any Processing sketch you have made or any example
in this book.
21.4 Images/ saveFrame( )
High-resolution PDFs are useful for printing; however, you can also save the contents of the Processing
window as an image fi le (with the same resolution as the pixel size of the window itself). is is
accomplished with save( ) or saveFrame( ) .
fi g. 21.4
If you include “####”
in the fi lename—
“3D-####.pdf”—separate,
numbered PDFs will be
made for each frame that
is rendered.
Exporting 403
save( ) takes one argument, the fi lename for the image you want to save. save( ) will generate image fi les
with the following formats: JPG, TIF, TGA, or PNG, indicated by the fi le extension you include in the
fi lename. If no extension is included, Processing will default to the TIF format.
background(255,0,0);
save( "file.jpg");
If you call save( ) multiple times with the same fi lename, it will overwrite the previous image. However,
if you want to save a sequence of images, the saveFrame( ) function will auto-number the fi les. Processing
will look for the String “ #### ” in the fi lename and replace it with a numbered sequence of images. See
Figure 21.5 .
fi g. 21.5
void draw() {
background(random(255));
saveFrame( "file####.jpg");
}
is technique is commonly used to import a numbered sequence of images into video or animation software.
21.5 MovieMaker
e image sequence that resulted from saveFrame( ) can be made into a movie fi le, using QuickTime Pro,
iMovie, or any number of video software packages.
For longer movies, however, having a directory full of thousands of images can prove to be a bit unwieldy. Using
the MovieMaker class makes this process easier by writing the frames directly to a movie fi le. I originally
developed MovieMaker as a contributed library, but it is now available in Processing’s video library itself.
import processing.video.*;
A MovieMaker object requires the following arguments (in order):
• this —Refers to the sketch that the movie will be associated with.
• width —An integer, typically the same width as the sketch.
404 Learning Processing
• height —An integer, typically the same height as the sketch.
• filename —A String for the movie’s file name.
• framerate —A frame rate for the movie, typically 30.
• type —What compression format should the movie use.
• quality —The compression quality for the movie.
An example of the constructor is as follows:
mm = new MovieMaker(this, width, height, " test.mov " , 30, MovieMaker.H263,
MovieMaker.HIGH);
e library off ers many options for compression codecs. e term codec originally comes from the term
“ coder-decoder, ” referring to a hardware device that converts analog video to digital. Here, however,
codec refers to a “ compressor-decompressor, ” software that coverts video between its raw, uncompressed
form (for viewing) and its compressed form (for storage). e following are the codecs available with the
MovieMaker library (check the reference page for any updates to this list: http://processing.org/reference/
libraries/video/MovieMaker.html ) .
ANIMATION, BASE, BMP, CINEPAK, COMPONENT, CMYK, GIF, GRAPHICS, JPEG,
MS_VIDEO, MOTION_JPEG_A, MOTION_JPEG_B, RAW, SORENSON, VIDEO, H261,
H263, H264
Selecting a codec will aff ect the size of the movie fi le as well as the quality. RAW , for example, will store
the video in its raw uncompressed (and therefore highest quality) form, but will result in an enormous
video fi le. You can read more about the various codecs at Apple’s QuickTime site.
• QuickTime: http://www.apple.com/quicktime/ .
• QuickTime Developer: http://developer.apple.com/quicktime/ .
Once you have selected a codec, you must then specify a codec quality, ranging from worst to lossless.
WORST, LOW, MEDIUM, HIGH, BEST, LOSSLESS
After the MovieMaker object is constructed, frames can be added one at a time to the movie by calling
the addFrame( ) function.
void draw() {
// Some cool stuff that you are drawing!
mm.addFrame();
}
Finally, in order for the movie fi le to play properly it has to be “ fi nished ” with the fi nishMovie( ) function.
If you quit the Processing sketch before this function is called, the movie fi le will not be recognized by
QuickTime! One solution is to fi nish the movie on a mouse click. However, if you are using mouse
presses already in your applet, you might want to consider other options, such as fi nishing on a key press
or after a timer has run out.
public void mousePressed() {
mm.finishMovie();
}
Exporting 405
Example 21-5 records a movie of a mouse drawing on the screen. e movie is fi nished when the space
bar is pressed.
fi g. 21.6 Output of Example 21-5
Example 21-5: Making a QuickTime movie
import processing.video.*;
MovieMaker mm; // Declare MovieMaker object
void setup() {
size(320, 240);
// Create MovieMaker object with size, filename,
// framerate, compression codec and quality
mm = new MovieMaker(this, width, height, "drawing.mov", 30, MovieMaker.H263,
MovieMaker.HIGH);
background(255);
}
void draw() {
stroke(0);
strokeWeight(4);
if (mousePressed) {
line(pmouseX, pmouseY, mouseX, mouseY);
}
mm.addFrame(); // Add window's pixels to movie
}
void keyPressed() {
if (key = = ''){
println( "finishing movie ");
mm.finish(); // Finish the movie if space bar is pressed!
}
}
Exercise 21-3: Create a movie from any Processing sketch you have made or any example
in this book.
The MovieMaker class is part of
Processing’s video library.
A new frame is added to the movie
every cycle through draw( ).
Do not forget to fi nish the movie! Otherwise, it will not play properly.
406 Learning Processing
Lesson Nine Project
Choose one or both!
1. Incorporate sound into a Processing sketch, either by adding sound eff ects
or by controlling the sketch with live input.
2 . Use Processing to generate an output other than real-time graphics. Make a
print (using PDF). Make a video (using MovieMaker), and so on.
Use the space provided below to sketch designs, notes, and pseudocode for your
project.
Lesson Ten
Beyond Processing
22 Advanced Object-Oriented Programming
23 Java
This page intentionally left blank
Advanced Object-Oriented Programming 409
22 Advanced Object-Oriented
Programming
“ Do you ever think about things that you do think about? ”
—Henry Drummond, Inherit the Wind
In this chapter:
– Encapsulation.
– Inheritance.
– Polymorphism.
– Overloading.
In Chapter 8, we introduced object-oriented programming ( “ OOP ” ). e driving principle of the chapter
was the pairing of data and functionality into one single idea, a class . A class is a template and from
that template we made instances of objects and stored them in variables and arrays. Although we learned
how to write classes and make objects, we did not delve very deeply into the core principles of OOP
and explore its advanced features. Now that we are nearing the end of the book (and about to leap into
the world of Java in the next chapter), it is a good time to refl ect on the past and take steps toward the
future.
Object-oriented programming in Processing and Java is defi ned by three fundamental concepts:
encapsulation , inheritance , and polymorphism . We are familiar with encapsulation already; we just have not
formalized our understanding of the concept and used the terminology. Inheritance and polymorphism
are completely new concepts we will cover in this chapter. (At the end of this chapter, we will also take
a quick look at method overloading , which allows objects to have more than one way of calling the
constructor.)
22.1 Encapsulation
To understand encapsulation , let’s return to the example of a Car class. And let’s take that example out into
the world and think about a real-life Car object, operated by a real-life driver: you . It is a nice summer day
and you are tired of programming and opt to head to the beach for the weekend. Traffi c permitting, you
are hoping for a nice drive where you will turn the steering wheel a bunch of times, press on the gas and
brakes, and fi ddle with dial on the radio.
is car that you are driving is encapsulated . All you have to do to drive is operate the functions: steer( ) ,
gas( ) , brake( ) , and radio( ) . Do you know what is under the hood? How the catalytic converter connects to
the engine or how the engine connects to the intercooler? What valves and wires and gears and belts do
what? Sure, if you are an experienced auto mechanic you might be able to answer these questions, but the
point is you don’t have to in order to drive the car. is is encapsulation .
Encapsulation is defi ned as hiding the inner workings of an object from the user of that object.
410 Learning Processing
In terms of object-oriented programming, the “ inner workings ” of an object are the data (variables
of that object) and functions. e “ user ” of the object is you, the programmer, who is making object
instances and using them throughout your code.
Now, why is this a good idea? Chapter 8 (and all of the OOP examples throughout the book)
emphasized the principles of modularity and reusability. Meaning, if you already fi gured out how to
program a Car, why do it over and over again each time you have to make a Car? Just organize it all
into the Car class, and you have saved yourself a lot of headaches.
Encapsulation goes a step further. OOP does not just help you organize your code, it protects you from
making mistakes . If you do not mess with the wiring of the car while you are driving it, you are less
likely to break the car. Of course, sometimes a car breaks down and you need to fi x it, but this requires
opening the hood and looking at the code inside the class itself.
Take the following example. Let’s say you are writing a BankAccount class which has a fl oating point
variable for the bank account balance .
BankAccount account = new BankAccount(1000);
You will want to encapsulate that balance and keep it hidden. Why? Let’s say you need to withdraw money
from that account. So you subtract $100 from that account.
account.balance = account.balance – 100.
But what if there is a fee to withdraw money? Say, $1.25? We are going to get fi red from our bank
programming job pretty quickly, having left this detail out. With encapsulation, we would keep our
job, having written the following code instead.
account.withdraw(100);
If the withdraw( ) function is written correctly, we will never forget the fee, since it will happen every
single time the method is called.
void withdraw(float amount) {
float fee = 1.25;
account – = (amount + fee);
}
Another benefi t of this strategy is that if the bank decides to raise the fee to $1.50, it can simply adjust
the fee variable inside the BankAccount class and everything will keep working!
Technically speaking, in order to follow the principles of encapsulation, variables inside of a class
should never be accessed directly and can only be retrieved with a method. is is why you will often
see programmers use a lot of functions known as getters and setters , functions that retrieve or change
the value of variables. Here is an example of a Point class with two variables ( x and y ) that are accessed
with getters and setters.
A bank account object with a
starting balance of $1,000.
Withdrawing $100 by accessing
the balance variable directly.
Withdrawing $100 by
calling a method!
This function ensures that a
fee is also deducted whenever
the money is withdrawn.
Advanced Object-Oriented Programming 411
class Point {
float x,y;
Point(float tempX, float tempY) {
x = tempX;
y = tempY;
}
// Getters
float getX() {
return x;
}
float getY() {
return y;
}
// Setters
float setX(float val) {
x = val;
}
float setY(float val) {
if (val > height) val = height;
y = val;
}
}
If we wanted to make a point and increment the y value, we would have to do it this way:
p.setY(p.getY() + 1);
Java actually allows us to mark a variable as “ private ” to make it illegal to access it directly (in other words,
if you try to, the program will not even run).
class Point {
private float x;
private float y;
}
While encapsulation is a core principle of object-oriented programming and is very important when
designing large-scale applications programmed by a team of developers, sticking to the letter of the law
(as with incrementing the y value of the Point object above) is often rather inconvenient and almost silly
for a simple Processing sketch. So, it is not the end of the world if you make a Point class and access the x
and y variables directly. We have done this several times in the examples found in this book.
However, understanding the principle of encapsulation should be a driving force in how you design your
objects and manage your code. Any time you start to expose the inner workings of an object outside of
the class itself, you should ask yourself: Is this necessary? Could this code go inside a function inside the
class? In the end, you will be a happier programmer and keep that job at the bank.
The variables x and y are accessed
with getter and setter functions.
Getters and setters allow us to protect
the value of variables. For example,
here the value of y can never be set to
greater than the sketch’s height.
Instead of:
p.y = p.y + 1;
Although rarely seen in Processing
examples, variables can be set as
private, meaning only accessible
inside the class itself. By default all
variables and functions in Processing
are “public.”