For online discussions, please read the following:

• netiquette

For your critique, find an interesting visualization from one of the following types of sources:

• textbook
• science magazine (Nature, Science, Scientific American, ...)
• magazine or newspaper (Newsweek, The Economist, NY Times, USA Today, ...)

You may not use papers or textbooks on visualization. Go to original sources used by practitioners and researchers. For this assignment, please do not use examples pulled from the web except from sites in the above categories.

Once you have selected your visualization, explain the data being shown (type and semantics) and the visual encodings used -- put into words what the visualization is trying to show. Next, critique the visualization: what works and what doesn't? Is the visualization clear or is it misleading? Do you like it (or not), and why? What could be improved? Compose your explanation and critique in 3-4 paragraphs and post your text and visualization in a new thread. Please format your thread title like this:

• Week 4: (insert title of the visualization you're critiquing)

Each week you are required to actively participate in one of the new threads for that week (except for the week that you are posting a critique). Your comments should be thoughtful; a single sentence saying "I like it" is not enough! Do you agree with the critique? If so, why (or, why not)? Did the critique miss anything? Did you learn something new? Please be constructive, not critical. Your peers will be discussing your critique as well!

Grading
We will check that the group thread has been created by midnight each Thursday -- the late policy applies to critiques as well. Your grade will be based on how well you describe and critique the visualization you post based on the language and concepts we have covered in class. Additionally, we will check that each class member has commented on a new thread before midnight each Sunday. If you posted a critique for the week you do not need to comment on another critique. However, you should participate in the discussion on your thread; don't leave a good discussion hanging, especially if there are questions! Your bulletin board activity each week will be part of the participation component of your final grade.

Visualization Tool
For this assignment you will be using Tableau, a commercial database visualization tool that supports many different ways to interact with data. One goal of this assignment is to provide you with the skill to learn and evaluate the effectiveness of tools like Tableau.

(For students wishing to install Tableau on their personal computer...) We have a class license available here (OS X and Windows are supported). The license will last for one year.

(For students wishing to use Tableau in a computer lab...) Tableau has also been installed in the Engman Lab (WEB L210) on the ten closest computers to the Help Desk: LAB5-82 through LAB5-91. When you open Tableau, it will ask you to simply register your email. To access this lab, you will want to create an account and register your U-Card through the CoE user tools.

You can find a wealth of information for Tableau online:

• Introduction to Tableau Video
• Tableau Tutorial Workbook
• Tableau 8.0 Help
• Tableau Quickstart Guides
• Tableau Online Training

Tableau's data visualization software is provided through the Tableau for Teaching program.

Data Sets
Now that you have a visualization tool, you need data to explore! We have provided the following two data sets and encourage you to use one of them in order to focus more of your time on exploring and analyzing the data. That said, you are welcome to use a different data set if you prefer; please contact the course staff if you are unsure about your choice. Please note the data set you have chosen in your notebook.

movie data: This data set contains information on a large sample of movies. The data includes the movie budget and revenue from different sources as well as ratings from RottenTomatoes and IMDB.

Download: csv file
Source: Jeff Heer

flight data: FAA data describing every commercial flight during the month of December 2009. For detailed descriptions of each data column in the attached file, please see www.transtats.bts.gov. You are also welcome to download your own version of the file (which might include columns or time spans that were left out from this data set) directly from www.transtats.bts.gov.

Download: csv file
Source: www.transtats.bts.gov

Many other sources for data sets can be found on the resources page.

Formulate a Question
Before exploring the data, pose an initial question that you would like to answer. For example: is there a relationship between melting point and atomic number? Are the brightness and color of stars correlated? Are there different patterns of nucleotides in different regions of human DNA?

Next, assess the fitness of the data for answering your question. Inspect the data -- it is invariably helpful to first look at the raw data values. Does the data seem appropriate for answering your question? If not, you may need to find a new initial question. Next, does the data need to be reformatted or cleaned before you analyze it? Perform any steps necessary to clean the data prior to visual analysis.

Write down the initial question clearly in your notebook, and describe any data wrangling you had to perform.

Data Exploration and Analysis
After you have an initial question and a data set, construct a visualization in Tableau that provides a potential answer to your question. As you construct the visualization, you will find that your question evolves -- often it will become more specific. Keep track of this evolution and further questions that occur to you along the way in your notebook. Also, keep copies of any intermediate visualizations you generate, and please include in your notebook several images of the more important visualizations that helped you refine your question.

NOTE: We are interested in seeing the evolution of your thoughts and investigation. We are not interested in just a final answer! Please document your discovery progress.

Once you have answered all the questions to your satisfaction, think of a way to present the data and the answers as clearly as possible. Include an image of your final visualization in your notebook, along with a caption and a paragraph description of how it answers the question you posed. Think of the figure, the caption, and the paragraph as material you might include in a research paper.

Submission Details
This assignment must be submitted as a PDF file via Canvas.

Grading
You will be graded on how well you address the following:

1. 05 pts: Data source specified
2. 15 pts: Initial question and description of any necessary data wrangling
3. 60 pts: Description of whether / how / why / when the question evolves, along with screenshots
4. 20 pts: Final image with caption and description

Please format your notebook so these are easy to find; effectively communicating information to humans is an essential part of this course! If we can't find something in a reasonable amount of time, you will not recieve credit for it. Here's an example of the kind of thing we're looking for.

In this assignment, you will be implementing the code described in Chapter 4 of Ben Fry's book: Visualizing Data; we have provided you with a copy of the chapter. Please note that some of the scanned figures are distorted; thus, your visualization may look slightly different than what you see, which is okay! For each of the steps below, include a screenshot of your visualization and answer the questions in a (digital) notebook (similar to the DATA EXPLORATION assignment). You will be submitting this notebook and the final version of your code for the assignment.

Before reading the chapter, download and install Processing, and explore the examples online. We highly recommend you go through some of the tutorials, in particular the first four at the Beginner level.

Complete the following steps. Feel free to make changes to the design of the visualization as you see fit, and, if you do, be sure to justify those changes in your notebook.

1. Download timeSeries.zip and extract it. This will be your project directory; to add code, simply open timeSeries.pde in Processing. No need to download additional files, just start programming!
2. Read pages 54-72, and implement the code described in the book. Change the numerical labels on the x- and y-axes to use the Georgia font, and all of the text titles to use the Verdana font. Choose a font size that seems most appropriate to you. Change the y-axis title to run along the axis, i.e. rotate it by 90-degrees (hint: look under the Transform section of the reference page). Make any other changes you feel are appropriate. What did you change and why?
3. Read pages 73-82, and implement the code described in the book. Allow the user to select which representation to render the data using the keyboard. Specifically, let 1 select dots; 2 select connected dots; 3 select line chart; 4 select filled chart. (hint: look under the Input section of the reference page). Use the Georgia font for the highlight tags on mouse rollover. What representation do you think is the most appropriate, and why?
4. Read pages 83-93, and implement the code described in the book. You may skip the Better Tab Images section if you want. For the interpolation, a new Integrator class has been provided for you. Is this tool an effective way to look at time series data? Why or why not? What is missing? How would you change the tool to support looking at time series with many time points (like > 1000)?
5. Next, add an additional tab for a summary view of all the time series data displayed at once. Choose a method for displaying the time series data that you feel is most effective for displaying multiple series. You do not need to support mouseover in this view, but you can if you wish! Why did you choose this visualization method?
6. For 6630 students only. A common statistical technique for time series data (and scatterplots in general) is finding a regression curve. The simplest form of regression is linear regression. You will be using linear regression to get an equation of a line and mapping this onto each time series plot. To get the equation of the line, you are welcome to pre-compute this in any statistical software (e.g. Excel, R, etc.), use an existing library in Processing or Java, or implement the algorithm in your code. In your visualization, overlay a regression line on each of the individual time series plots. Is there any representation of the time series data where a regression line is less effective? Why?

Recommended Books

• Visualizing Data, by Ben Fry
• Getting Started with Processing, by Casey Reas and Ben Fry
• Learning Processing, by Daniel Shiffman (free e-book through the Marriott Library)
• Processing: A Programming Handbook for Visual Designers and Artists, Casey Reas and Ben Fry (free e-book through the Marriott Library)

Submission Details
In addition to your PDF notebook, you will be submitting your final Processing code for this assignment. Please ZIP up your entire project directory (code and data) to include in your submission. We expect to be able to run your visualization as is. Make sure that your file paths are relative!!! Both the PDF and ZIP archive should be submitted via Canvas.

Grading
You will be graded on how well you address the following:

1. 20 pts: When unzipped, project runs without errors or modifications on our part
2. 05 pts: Axes and rollovers use the Georgia font, text titles use Verdana
3. 05 pts: Rotated y-axis label
4. 10 pts: Keyboard selection for different chart types
5. 10 pts: Justification of best chart type
6. 10 pts: Analysis of tool
7. 15 pts: Additional summary tab
8. 10 pts: Justification of summary chart
9. 10 pts:* Regression line
10. 05 pts:* Analysis of regression line inclusion

*These are only required for CS 6630 students. For CS 5630 students, your final point total will be scaled to a range of [0,100].

Please format your notebook so these are easy to find; don't forget the appropriate screenshots! If we can't find something in a reasonable amount of time, you will not recieve credit for it.

First, you will want to understand what parallel coordinates are. Please read the following short discussions:

• Ch. 7.6.2 Parallel Layouts, in Visualization Analysis and Design by Tamara Munzner
  
• Section 11.6 Multivariate Data Visualization, in Data Visualization by Alexandru Telea

Next, play around with this nice example written by Jason Davies in the D3.js language. Different data can be seen in the veterans and nutrient contents examples by Kai Chang. In these examples, note that you can filter along an axis and rearrange axes. Think about what you like in the designs and what you would want to do differently. There are many different ways to encode, layout, and interact with data in a parallel coordinates plot -- these examples are just one way to do this. There is no "right" answer!

Data Wrangling
To start, download the cars data set, provided below. Inspect the data -- it does not come in the .csv file format that you worked with in the TIME SERIES assignment. The data needs to be cleaned and processed to get it into Processing. You are welcome to re-use the FloatTable.pde file reader from the previous assignment to import the data.

Basic Visualization
Before writing code, pull out a piece of paper. Create a paper prototype of what you envision the visualization will look like. Consider the basic items that you will render: like axes, data, title, labels, tick marks, etc. Think about how you plan to handle overlapping lines (e.g. use transparency). Scan or take a picture of your paper prototype and put it in your notebook.

Next, create a Processing sketch for the assignment based on your paper prototype. Get the cars data set imported (feel free to use FloatTable.pde), and write a basic renderer to create a static parallel coordinates plot. In your sketch, be sure to label everything you can: titles, tick marks, ranges, etc. In your notebook, include a screenshot of this static version of your visualization. Were you able to include everything that you had thought of in your paper prototype? Please record some of your thoughts on this sketching and coding process in your notebook.

Interactivity
Now, for the fun part! Parallel coordinates are hardly useful without interactivity. Instead of worrying about how to code interaction, first set the computer aside and pull out another piece of paper. Think about how you want to interact with the axes and the data. How would you design these interactions to make them effective? At a minimum, you must support the following basic interactions:

• filter the data across multiple attributes
• reorder / rearrange the axes
• invert the axes

For each of these interactions (and any more you want), draw a series of story boards, i.e. a sequence of sketches that illustrate the steps behind an interaction in the visualization. Be sure to show any interface elements that the user will interact with. This just needs to be enough to give you an idea of what you want to write in the code. Then, create a digital copy of your story boards, and add each of the story boards to your notebook with a brief description of what is occurring in each story board.

Next, implement your ideas!

In your notebook, include a screenshot of your interactive visualization, describe how your interactivity works, and justify your design decisions using concepts we have covered in the class. Does your design work? What could be improved, given more time, and how? Did you come up with any interactivity mechanisms to support tasks other than those described above?

Clustering (for 6630 students only | extra credit for 5630 students)
It is often useful to aggregate multidimensional data into clusters of similar data points. A very simple method for aggregation is k-means clustering. For this portion of the assignment you must use k-means clustering to aggregate data, and develop a way to show the clusters in your visualization.

You may use existing k-mean clustering algorithms to create your clusters, or be adventurous and implement it yourself (it is straight-forward to do). Experiment with the number of clusters you create and find a number that does a good job in creating meaningful clusters. We would recommend doing this experimentation in your visualization once you implement a visual representation for the clusters.

The most obvious way to show clusters is to assign each cluster a color (hue) and render the data (lines) in the appropriate color according to their cluster membership. When encoding categorical data with color, however, remember that we can only distinguish a limited number of colors -- how many can we actually distinguish? Design your visual encoding accordingly. You are free to develop a different way to encode the clusters if you would like. However you encode the clusters, allow the user to choose to show the clusters, or not. Include a screenshot of your visualization with the cluster encoding in your notebook along with a description of your encoding method.

extra credit: A way to accommodate a limited color palette is by creating an interactive color legend. An example is shown in the image on the right. This legend allows the user to apply a color to a specific group, or have a default color of gray. This visualization widget thus serves dual purpose: it works as a legend to inform the user about the encoding, and it also lets the user dynamically set the color of each group. Implement your own interactive color legend.

Data Exploration
Explore at least two data sets (one of which should be the cars data set) in your parallel coordinates tool. What interesting features can you find? For each data set, document several features that you find, and include both a description and a screenshot of each in your notebook.

Lastly, critique your parallel coordinate visualization in your notebook. What do you think of parallel coordinates as a visualization representation? Do you find it easy or hard to use? Could you have found those same features without interactivity? What are the limits of parallel coordinates for data other than quantitative data, and how might you visualize that?

Data Sets
We have provided the following two data sets and encourage you to use both of them in order to get started quickly and therefore have more time to explore the data and develop your visualization tool -- we recommend you develop your visualization using the cars data set. You are welcome to use a different second data set, if you prefer.

cars: This data set contains information on 406 different cars from the 1983 ASA Data Exposition data set.

Download: repository
Source: American Statistical Association

cameras: This data set contains information about 1000+ digital cameras and 13 different attributes.

Download: tsv file
Source: the ScatterDice project

Many other data sets can be obtained from XmdvTool or R data sets.

Submission Details
As before, you must submit your PDF notebook and ZIP archive of your data and code via Canvas. We should be able to run your code as is.

Grading
You will be graded on how well you address the following:

1. 10 pts: When unzipped, project runs without errors or modifications on our part
2. 05 pts: What did you have to do to import the cars data set?
3. 05 pts: Paper prototype of basic visualization
4. 20 pts: Implemented basic visualization
5. 05 pts: Storyboards and descriptions of interactivity
6. 25 pts: Implemented interactive visualization
7. 05 pts: Analysis of design
8. 10 pts:* Implementation and description of clustering encoding
9. 10 pts:† Implementation of interactive color legend
10. 05 pts: Data exploration findings
11. 10 pts: Critique of technique

*These are only required for CS 6630 students, or may be done for extra credit by CS 5630 students. For CS 5630 students, your final point total will be scaled to a range of [0,100] (not including extra credit).
†This is extra credit for everyone.

Please format your notebook so these are easy to find. If we can't find something in a reasonable amount of time, you will not recieve credit for it.

Data Reader

This time around, you will be writing your own data reader in Processing to generate an image. To start off, you will be using two data sets: test.nrrd and brain.nrrd. Note that this data uses the NRRD file format. You can find the definition of the NRRD file format as well as several different example NRRD files online.

It is important to understand what is represented in the header and how this connects to the format of the data below the header. In particular, the dimension component describes that we have a regular 2-D grid. Also, the sizes component gives us the width and height of this grid, respectively. Lastly, the encoding component tells us that we have data written as text (human-readable).

After the header, each row of our data represents a single point in the grid. For this assignment, each row contains one scalar value. The grid iterates through the x-axis first, then the y-axis.

With the NRRD format in mind, write your data reader in Processing that will store the data in your sketch. Storing the data in a 2-D array is recommended. For more on 2-D arrays, see the corresponding Processing tutorial. Be sure that you also read in the important values from the header, particularly the sizes components, to set the two dimensions of your data array. You should only be reading in data during the setup() function, not within your draw() loop. Some functions to consider: loadStrings(), for(), split(), and float().

Once you have imported the data into your sketch, create a grayscale image using the same dimensions as the data grid for both of the datasets. See the examples in FIGURE 1 and 2 -- NOTE that FIGURE 1 has been zoomed in from an 8x8 image so that you can see the results. For drawing each data point, we recommend using either rect(), point(), or PImage(). Be mindful of your fill() and stroke() values in your draw loop. You may wish to add a mouse or key command to save your sketch as an image: save().

In your digital notebook, add in your grayscale images, and be sure to answer the following:

• Was it easy to import the data?
• What problems did you have?

Applying a Color Map

Time to apply some color! First, choose an appropriate color map from ColorBrewer or another source. Interpret this color map into a continuous space; do not use a binned color map. One way to do this is to use two or three colors that are starting, middle, and ending values for your color map. You will need a function that will take a scalar value and then map it to a color along your new continuous colormap.

Now, for each scalar value, map or convert these data values into colors using your color map. This assigns a color to each pixel of your image. This should produce a continuous color image for your data, and look something like FIGURE 3. Some functions to consider: map(), lerpColor().

In your digital notebook, add your color mapped image, and be sure to answer:

• Where did you get your color map?
• What makes it an appropriate color map for this data?

You may want to experiment with several colormaps. If you do, make sure to include screenshots of your work!

Interpolating the Grid
Next, we will make our image larger by changing the size of our Processing sketch. Instead of using the sizes of our grid, we will fix the height of our sketch to 800 pixels. Keep the same aspect ratio for the grid (preserve the ratio of width to height).

After creating a larger sketch, map your original data grid values into the appropriate pixel values to fill the screen. This will result in an image that looks pixelated, as in FIGURE 1. Do this for both datasets.

Keep in mind that Processing expects integers in its size() function, but division with integers can result in rounding issues in programming languages. You can always convert or cast your data from floating point numbers into integers for this function.

To smooth out our image, we will perform bilinear interpolation of the data. This process first maps every pixel on our screen into the data grid, and determines its location in floating point. This position will lie between four values of that grid. We find an interpolated value using these four grid points and the ratios of distances to them. Be mindful of the pixels on the edges of the image. Finally, this interpolated color value is looked up in the color map. Create an image for both datasets using bilinear interpoloation (again, with the images having a width of 800 pixels and appropriate aspect ratio). In FIGURE 4 we have a zoomed in region from the brain dataset showing the difference between nearest-neighbor (left) and bilinear interpolation (right). In FIGURE 5 you can see the results of smoothing the test image. Include in your notebook a zoomed in region of the brain dataset that shows something similar (but of any region of the image). You can create these zoomed in images in an image view tool, or in your Processing tool.

In your digital notebook, add the interpolated brain images, as well as the comparison to nearest neighbor, and be sure to answer:

• What, if anything, makes interpolation of your data tricky?
• Do you notice anything odd about the data? Do any values stick out?

Note that in the next part of the assignment you will be using a different technique to visualize this data (isocontours). You will need to switch between these two modes use keystrokes. This is an FYI for planning how you structure this part of the assignment!

Isocontours using Marching Squares

Isocontours are another technique for exploring scalar data sets. In 2D, these are simply a set of isolines overlaid on your image. For generating isocontours, you will be implementing the marching squares algorithm. This algorithm generates isolines along the different cells of our data grid. Before you get started with this part of the assignment, you will want to read these few pages which include a step-by-step description of the algorithm.

Write your own marching squares algorithm to generate and draw isocontours. Allow the user to switch between our color-mapped image and the isocontours using the 'c' key. For the isocontours mode, you must draw all the isocontours at a single isovalue. To draw isolines in Processing, you can use beginShape()/endShape() or line().

Note that, you should still keep your display of a fixed height of 800 pixels. However, you should isocontour on the original data and then scale up the position of the isocontours appropriately. This is not equivalent to isocontouring the bilinearly interpolated data!

To help with debugging focus first on the test dataset. This data set is just random noise, but at an isovalue of 32700 it hits all 16 cases of marching squares. See the sample image in FIGURE 5 for the properly generated isocontours.

Next, with your working marching squares algorithm, test different isovalues on the brain data set. See what values of the data highlight different portions of the image. Take note of potentially interesting or uninteresting ranges of this data set. We have provided another sample image at isovalue 176 in FIGURE 6. Feel free to play around with interactions to set or change isovalues. This can allow you to more easily explore the data set, but it is not required.

In your digital notebook, be sure to add an image of the test data set at the same isovalue as in FIGURE 5. Additionally, add several images of interesting isovalues you found in the brain data set. Be sure to also answer:

• Are there any problems with your marching squares algorithm?
• What is an interesting isovalue on the brain data set? Why?
• Compared to a color map, are there any tasks that isocontours seem more effective for? Why or why not? Which technique do you think is better?

Data Exploration
Now that you have explored the brain data set, let's look at a new scalar grid! We are providing a height field data set, showing the elevation around Mt. Hood: mtHood.nrrd.

First, test your color map technique. You can see a sample image in FIGURE 7. Play around with your colormaps for this data set and choose a colormap that you think is most appropriate.

Next, explore different isocontours. Try to find interesting values and patterns that you maybe could not see in the color map. Compare how these contours look versus the contours you saw in the brain data set.

In your digital notebook, include a couple images showing your color map and changes for the mtHood data set, along with a couple images for isocontours. Additionally, answer the following:

• How did you adjust your color map for the mtHood data set?
• Did the isocontours in the mtHood dataset differ from the brain data set? Why?
• For the brain and mtHood data sets, were either color maps or isocontours more effective for either one of these data sets? Why?

Extra Credit 1: Higher Order Interpolation
Instead of using bilinear interpolation in both your colormapping and isocontouring techniques, implement bicubic interpolation. This is a different interpolation function for reconstructing data values between grid vertices. Obtain images using both techniques and compare them. Feel free to try out different sizes of images to compare the two interpolation methods. Allow the user to switch between bilinear and bicubic interpolation methods using the 'i' key. Include sample images of both bilinear and bicubic in your digital notebook, and answer the following:

• What does bicubic interpolation change in the output image?
• Does bicubic interpolation make a difference when we have a larger image?
• Are there any features that bicubic interpolation is better for?

Extra Credit 2: Efficient Coding
The complete marching squares algorithm can be written in just three lines of "real" code. For those of you optimization-lovers out there, can you figure this out? Hint: the three lines of Processing code will go between beginShape() and endShape() calls. Include your nifty code snippet in your digital notebook.

Data Sets
We have provided the following three data sets for this assignment. They all use the NRRD file format.

brain.nrrd: This data set contains scalar values measured from a 2D slice of a brain.

test.nrrd: This data set is a randomly-generated 2D grid of noise. source: Gordon Kindlmann

mtHood.nrrd: This data set contains scalar values measured from a 2D spatial grid which represents a height field around Mount Hood in Oregon.

Recommended Resources

• Processing Language Reference
• NRRD File Format Examples
• Bilinear Interpolation
• Bicubic Interpolation

Submission Details
As before, you must submit your PDF notebook and ZIP archive of your data and code via Canvas. We should be able to run your code as is.

Grading
You will be graded on how well you address the following:

1. 10 pts: When unzipped, project runs without errors or modifications on our part
2. 05 pts: Data Reader images and discussion
3. 20 pts: Color Map image and discussion
4. 25 pts: Interpolation images and discussion
5. 30 pts: Isocontour images and discussion
6. 10 pts: Data Exploration images and discussion
7. 10 pts:* Extra Credit 1
8. 20 pts:* Extra Credit 2

*These are extra credit for everyone.

Please format your notebook so these are easy to find. If we can't find something in a reasonable amount of time, you will not recieve credit for it.

Understanding Transfer Functions

To begin this assignment, you will explore a volume rendering tool: ImageVis3D. They also have several sample volumes for you to download. Download one or more of these sample volumes, and load them into ImageVis3D. Then, in "Workspace", click on the "1D transfer function editor." Now, you will explore this editor to create your own custom transfer functions for your selected volume. Try and make a decent image; notice that this is not easy to do! Pay attention to the critical alpha channel, as this allows you to effectively hide different portions of the volume.

In your write-up, include the data set you chose to explore and several images of different stages of your exploration. Then, answer the following:

• What did you like about the transfer function editor?
• What is difficult about this editor / widget?
• How would you improve the 1D transfer function editor?

Running the Volume Renderer

A challenging concept for volume rendering is transfer function design. As such, we are providing you with a volume renderer, courtesy of Dr. Christoph Garth at the University of Kaiserslautern. You can find the code for the assignment here. You will be modifying a single file ( Controls.java ), which will update the control panel window.

First, test the volume renderer as it is. You will need to download the assignment code as well as the latest version of Processing -- NOTE: this assignment requires you to be running Processing 2.1! If you have a slower computer, you may wish to go to the Engman lab as the volume renderer will rely on a fairly modern GPU; the computers in the Engman lab run the code well (see the data exploration assignment). Load this program up in Processing and run it. You should successfully get a screen as on the right.

Volume Visualization and Control Panel
In the volume rendering window, you can move the dataset around using the left and right mouse keys + dragging. This style of panning and zooming interaction is nearly universal for volume visualization tools.

After running the program, explore the current GUI for the control panel. The control panel widgets are generated using the controlP5 library, a Processing widget library that many use for buttons, sliders, etc. Explore this interface. You can choose different data sets and details about each will be printed in the Processing console. You can edit lighting settings, or disable them completely. Different settings for lighting often play a critical role in effective 3D images.

The last set of options in the control panel deals with transfer functions. The center and density variables tweak the parameters to a step function, which is the default transfer function mode. There is also a color picker below that, but please note that the alpha channel is not used. Choose one of the data sets provided and tweak the step transfer function and lighting settings, in order to produce an effective rendering of your volume. Attach a screenshot of both the control panel and the volume, and then answer the following:

• What were you able to find from your volume data set?
• What is useful about the step function?
• What makes this particular function limited?

Code Structure
The main Processing sketch ( TransferFunctions.pde ) has very little code because it calls two other files: one for rendering the volume ( VolumeRenderer.java ) and another for creating a control panel ( Controls.java ). For this assignment, you will only be required to edit the control panel, and you are welcome to treat the rest of the code as a black-box that just works. For those more experienced with Java, OpenGL, and GLSL, you are welcome to explore more, if you wish, but be sure you complete the assignment. If you have any difficulties, feel free to contact a TA.

Designing Your Own Transfer Function Widget
The main purpose of this assignment is for you to design your own 1D transfer function widget. But first, you should take a step away from the code and go back to pencil and paper. Think about different ways to represent and encode a 1D transfer function. What controls will the user have access to? What user interactions will exist to make it a useful widget? You may also wish to consider the extra credit, at the end of the assignment. Try out multiple ideas, sketch two or three possible widgets that are significantly different. Scan each of your sketches into your digital notebook and explain how the interactivity works in each.

Note that most transfer function widgets give the users some context about the distribution of scalar values in the volume, ie. they often show histograms of the scalar values. These histograms can help a user to select appropriate colors and alpha values by targetting the most (or sometimes least) prevalant values. You may want to consider "scenting" your transfer function widget with a histogram.

Pick one to implement. You will be creating your widget so that it shows up on the empty, right-hand side of the Control Panel window. You will implement this widget using Processing code, and below we describe in detail where this code goes and what aspects of the existing data structures your widget must modify. The end result of your code will be to take the user input from your widget and use it to fill in the specific data structures in the code that specify the transfer function values (for both color and alpha).

Your widget code will go in Controls.java. In the implementation details below we give details on how to use the code we have provided you. Include a screenshot of your interactive widget in your digital notebook and answer the following:

• Which of your different sketches was implemented in the code? How does it work? Why did you choose this idea?

Finding Good Transfer Functions

With your interactive widget, explore two of the included data sets, and create a good transfer function for each of them. See if you can find anything interesting or unique within your data sets. Include screenshots of your widget and the volume for each of the two data sets, and then answer the following:

• Did you find anything interesting in the data sets?
• What are the strengths and weaknesses of your design?
• What would you change to make your widget more effective?
• What are the pros and cons for volume rendering as a technique? What are the challenges?

Extra Credit
Design a 1D transfer function widget that uses a better perceptual color space for creating more effective transfer functions. You are welcome to use HSV or HSL, if you wish, but feel free to explore better color spaces, like Lab or HCL. What are the benefits of using a more perceptually uniform color space in creating transfer functions? What are the limitations or drawbacks of this approach?

If you choose to do this extra credit, you do not need to design your widget using RGBA -- you can start with this more advanced color space and complete the assignment with it.

Implementation Details
To aid with designing your widget, we have provided certain data structures for you to use. Again, be sure you are only editing in Controls.java, see right. Also, we have placed comments in that file, with the tag CS6630, to help you know where you should edit in-between. Unless you know what you are doing, we do not recommend editing code outside of there.

We have provided two variables, cWidth and cHeight, that will set the height and width of the control panel. The default elements of the control panel are set later in the file, but you should not need to edit them. The GUI of the control panel already gives you a button to switch between two transfer function modes. The second mode (custom transfer function) is the one you will use for your own widget.

We are also providing you with the volume data. First, an integer, gridSize, stores the number of data values on each edge of our 3D grid (which is uniform in all three dimensions). Also, data[x][y][z] is a 3D integer array that stores the scalar values of the volume, which have a range between 0 and 255. We also provide the min and max values for the current data set.

To define the transfer functions used by the volume renderer, your widget will need let the user set the color and alpha for each scalar value in the volume, and then fill in four different integer arrays with those values. These four arrays (red, green, blue, and alpha) each have a size of 256, which represents the scalar values 0-255. At each array element you'll need to set the appropriate color channel value for that scalar value. For example, if I want the scalar value of 10 to be transparent red, I'd set red[9]=255, green[9]=blue[9]=0, and alpha[9]=150. The color channel array values should be between 0 and 255. Thus, to find the color for the scalar value of 255, the volume renderer will check the following: red[255], green[255], blue[255], and alpha[255]. Please note that we have white backgrounds, so if all the RGB values are 0, then you are using the color black. However, the alpha channel is set so that values of 0 are transparent and values of 255 are solid. By default, the RGBA arrays are all transparent white.

If you are scenting your transfer function widget with a histogram of the scalar field values, then be aware that some of the data sets will be dominated by a single value -- this is quite common in volumes. These dominate values are most often uninteresting, such as the background or noise. You are free to "process" your histogram or display it in such a way that will minimize these dominate values. Please make sure to explain what you do in your notebook.

Like in Processing, the code has a setup() method. Do not remove or change the ordering of the initial setup calls. But, you are welcome to add more to the setup if you wish. We also have a draw() method, where the bulk of your widget will likely be written. Please note that there is a special function, updateTransferFunction(), which will pass your RGBA arrays in their current form and update the volume renderer with that data, if you are set to the proper transfer function mode (custom transfer function). You do not need to call this every draw cycle, but you must have a clear way to call this function in your widget in order to update the volume renderer with the user's transfer function.

Since you are writing in a Java file, there may be some quirks with using Processing commands. For example, to create a color, Java officially recognizes them as an int (not color!). Also, if you wish to write your own methods, you must be sure to specify them as public or private, like the setup() and draw() methods. You can do this for Processing methods that work like normal, like mouseClicked() or mouseDragged(). There may be more quirks, and, if you have trouble, feel free to contact the TAs.

Submission Details
As before, you must submit your PDF notebook and ZIP archive of your data and code via Canvas. We should be able to run your code as is.

Grading
You will be graded on how well you address the following:

1. 10 pts: When unzipped, project runs without errors or modifications on our part
2. 15 pts: Exploration with ImageVis3D: images and discussion
3. 10 pts: Exploration with initial tool: images and discussion
4. 15 pts: Custom widget sketches and discussion
5. 40 pts: Custom widget implementation (functionality,usability, and creativity)
6. 10 pts: Exploration with custom widget: images and discussion
7. 10 pts:* Extra Credit 1

*This is extra credit for everyone.

Please format your notebook so these are easy to find. If we can't find something in a reasonable amount of time, you will not recieve credit for it.