Viewers: in countries Watching now:
Start communicating ideas and diagramming data in a more interactive way. In this course, author Barton Poulson shows how to read, map, and illustrate data with Processing, an open-source drawing and development environment. On top of a solid introduction to Processing itself, this course investigates methods for obtaining and preparing data, designing for data visualization, and building an interactive experience out of a design. When your visualization is complete, explore the options for sharing your work, whether uploading it to specialized websites, embedding the visualizations in your own web pages, or even creating a desktop or Android app for your work.
In the previous movie, we discussed how you could use custom functions, or blocks of code, to save time and to allow you to reuse code in later sketches. In this movie, I want to take that several steps further, by explaining to you classes and objects. Now, a function is usually something that you use in a static drawing, and every piece of information that you enter into it has to be of the same type, so all integer variables or all floats. In a class, however, you can throw in any kind of information you want, and more significantly, you can specify the operations that occur, the things that the drawing actually does with the class.
Now, a class is a template. It's a general category. And then when you instantiate something in a class, it becomes an object. So, you have a template and the realization. That's--the class is the template and the object is the realization of that class in your particular sketch. In this example, I'm not going to type the code in front of you, because there's a fair amount of code. I am, however, going to open it up and walk you through it. So here, in the Exercise folder, in Exercise 09_02, I actually have two files here, and the reason for that is because I created a class and I've put it on a separate tab.
And when you have more than one tab, each of those tabs gets its own folder in Processing. I'm going to double-click on this one right here and maximize that one. I decided for this example to create a pie chart that actually had a fair amount of random generation to it, a couple of user-specified parameters, and that also, a pie chart that actually grew over time. What I'm doing in this case is I'm actually creating five pie charts. Because it's modular, you can do things more than once now. Five is actually really pushing it for coding it in by hand.
Normally, by this point, I would be using an array of objects, which is actually a very good way to go. But I just wanted to emphasize the structure here for this one. So, I created an object called PieGrow, because it's a pie chart that grows. And the first thing I needed to do is I needed to declare both the class and the name of the object. So, what I have at the top are five statements of the class PieGrow, and then I have five objects: the pie1, pie2, and so on. So, that's like declaring a variable, except because it's a class and an object, it's a much more elaborate thing.
Beneath that, I have my setup where I do a 600 x 200 window and turn on the anti-aliasing. And beneath that is where I actually specify parameters. These are the ones that the user gets to specify. So, I put down, for each one of them, I put pie1-- that's the name of the objects that I created above--then equals and then new. That's something you have to do with objects. And then I put the name of the class PieGrow, and then in parentheses, that's where I put the two user-specified parameters. The first one is the name of the pie chart, and I just put them A through E.
And then the second one is how many radians around do you want the pie to go? And remember, it starts at 3 o'clock. And one radian is over to 9 o'clock, and two radians is all the way around. So, for instance, I have one here at 0.75. That's going to be less than halfway. But the fourth one down is 1.95. That's going to be a nearly complete circle. Anyhow, the nice thing is I don't need a whole lot of code here. That's all I have in the setup. And then I come down to draw and I put the background in, and then for each of my pies, I just have two behaviors, or two functions that each one of them do, and that is they update--that's to change the calculations--and then the display it--that is actually draw it--and I do each one of those things in turn.
And the Processing sketch will cycle through this, up to 60 frames per second, and see how it can adapt. Now, I did this so you can see how clean this can be when you use objects that you really don't have a lot of code in the drawing here per se. Instead, I have a fair amount of code here under PieGrow. That's the name of the class. So, at the top, it says class--that's all lowercase-- and then PieGrow. Class names actually start with capital letters. And then in the curly brackets, I put down all the variables that go into my pie chart.
There is the x and the y that position it. There is the d for the diameter. There is the angle for the start. That's where the slice of the pie chart begins. And then I have a angle for the middle as it goes around, and then I have an angle at the end where it stops. And the speed is how fast I want it to move. And then I actually have RGB for color. And then I have the string for the title that the user provides. Next, you have something called a constructor. And again, this is kind of a funny bit of logic, but what it is is this is something that takes the arguments that the user's provided, and it puts them in here to initialize the variables.
What's curious is that it has to actually use temporary variables for the initialization of anything the users provide. Now, if it's not based on a user-provided parameter, he don't need to use the temp stuff. So, you see, for instance, at the beginning, I have three variables here that are based on random numbers. The diameter of the pie is a random number between 50 to 250, so that's the diameter in pixels, and then the X and the Y coordinates for the center of the pie, those are also random coordinates. I did diameter first because I want to keep this from going completely off the window.
This will keep them on a little bit. Then the angle for the start is always going to be 0, and then the angle for the middle is temporarily at 0. That's going to change. And then the angleEnd is provided by the user, and I put that in there and multiply it times pie, because everything has to be in units of pie, so that's what that's for. Then I created a variable called speed, which would be different for each one of the pies. It would be somewhere between 0.005 and 0.005, and that is the change in the angle, measured in radians, as the pie sort of unravels.
Then I have random components for the red, green, and blue components of the color, and then I have the title. And then I finish the constructor there-- that's the initial values--and then I describe what my two methods are: the update and the display. For update, I want it to slowly move around the circle. So, it starts the angleMid, which currently is set at 0, will add on a small amount, and it will go around and circle clockwise. However, I don't want it to go too far. I want it to stop when it gets to the end, and the easiest way to do that is to just use a constraint. Say that the Angle Middle can't be less than 0, because that's where it starts, and it can't go past the user-specified ending value.
Also, I've got this curious little block of code here, which is going to allow me to click on the pies and move them around, because they are randomly positioned and they almost always end up covering one another. This allows me to move them a little bit. And then finally, I have the code displayed that actually draws the pies with Processing's built-in arc function. I just turn off the stroke. I specify the fill with the random RGBs. For arc, you need the X and the Y for the center. You need the diameter, both in terms of width and height.
You need the starting point and the ending point, and that's what I've got in there. And then I've also decided to put some titles on with the user-provided title. I turn those black and move those slightly below and to the right of the center. Anyhow, let me show you how this one works. It's a little silly, but here we go! I press Run, and what I get are five pie charts that are completely overlapping each other, and growing at different rates. But you see that's not something I could do with just a function. In fact, I'll do it again, so you see that we get different every time--different colors and different positions and different sizes.
Then that little loop I showed to you them allows me to reposition them-- if I get the cursor within the radius of the circle, I can start moving stuff around. And I click, I can move it there. What's kind of fun is when I get in the radius of two circles, it moves to both of them. They get locked up temporarily. But the point here is I've prepared a sort of data visualization, even though pie charts are usually not something you want to work with; it's because the arc function was easy to deal with in this one.
But I was able to take just a small amount of user information of different kinds of variables-- in this case, I got a string and a float variable from the user--and then I was able to produce this thing that was dynamic and that evolved as it worked, and allowed me to move it around, too, in a way you couldn't do with the function. And so classes and objects are one of the huge, huge time savers and most important tools you will have in data visualization and your programming work, and I strongly encourage you to take the time to play with them and see how you can make them work in your own Processing sketches.
There are currently no FAQs about Interactive Data Visualization with Processing.
Access exercise files from a button right under the course name.
Search within course videos and transcripts, and jump right to the results.
Remove icons showing you already watched videos if you want to start over.
Make the video wide, narrow, full-screen, or pop the player out of the page into its own window.