Dynamic Rehearsal Project from Rebecca Spitzer on Vimeo.

We did get a lot of great feedback, though, so that was really rewarding! I’m pleased with how much we got done, and it seems so was everyone else.

We’re spending this week wrapping everything up, making a display website and commenting up our code files. What a crazy couple of weeks!

The main thing that we’re excited about is the dynamic generation of screen elements, like the timeline at the top of the rehearsal workspace and the list of notes for each rehearsal. Each user has a newly generated color that appears on their timeline, on their notes, and in the key at the bottom of the screen. The video works (you can pause and play again!) and there is a slider that allows to you skip to new portions of the video. You can pull an individual note out of the stack, and it appears to the left of your rehearsal workspace for later review. And it looks good!

Screencaps:

Starting log-in screen (currently doesn’t have distinct user log-in codes, you just tap to start; we hope that in the future you can log in using the Surface as a fingerprint reader to automatically access your information.)

Overall look of all workspaces upon log-in, assuming four users are logged into the collaborative workspace.

Pulling an individual note out of the stack for review (The white highlight of the note marks it as “read” in the stack.)

Workspace for reviewing the most recent unread notes.

Panel to filter displayed notes by type or user; this button panel shows up when you tap on the timeline, allowing you to control what you’re reviewing.

Thumbnail spaces of past rehearsal. These are currently static, but in future implementations would have the ability to expand to the full size of the main rehearsal workspace we see to the right. This way, you’d be able to use all the real estate of the Surface size to review two rehearsal videos side by side for comparison.

Small key at the bottom of the Surface (can move to the opposite side depending on where you’re sitting) to show you who is logged in and what color refers to them.

Futhermore, there are other aspects of the project that are not clearly implemented at this stage; the project has a ubiquitous computing element consisting on a video camera that records rehearsals, RFID tags and readers to record when actors are onstage, and computerized pens that record notes being taken. Since there are no photos of the setup, here’s my small diagram:

We do HAVE each of the elements – a video camera, RFID tag readers, and the computerized pen, but none are linked together. The pen is the coolest part; it does indeed record the notes you’re taking! 

All in all, I’m pleased with the amount of work we’ve accomplished in only a few weeks; we have a working interface that is aesthetically presentable! I was originally very wary of C#, which the Surface is programmed in, and did most of my design work in XAML, which can control the look of the interface. In spending the last week integrating my XAML snippets with the existing C# code, however, I’ve become much more familiar with both languages. Hurrah! Our presentation is in 30 minutes and I hope to have some good feedback and discussion with attendees and other presentation groups; if we do, I’ll certainly discuss it here. There is also a video describing the whole project that has yet to be uploaded to the web; when it is uploaded, I will certainly link to it here.

At any rate, the central rehearsal review panel was redesigned to a vertical panel from a horizontal panel, which has pros and cons. The major problem with this is that the timeline across the top doesn’t have as much space to expand from side to side; a panoramic timeline is why we originally chose a horizontal interface. However, it turns out that resizing the timeline wasn’t as much of a problem as we thought it would be – it is slightly smaller, but still readable. The big plus side of moving to a vertical implementation is that we were able to get rid of the expanded timeline and move the notes under the video, which makes a lot of sense visually and frees up space elsewhere on the surface for other workspaces.

Those other workspaces are the previously discussed “Recent Notes” panel, which is actually smaller in our real implementation than pictured below, and the “Individual Note” panel, which is useful when a single note is pulled out of the stack for review. Additionally, I created a informational key to live at one edge of the Surface, providing data about the show itself and the list of current logged in users (and their colors).

The workspaces, as seen in Blend, not quite as implemented:

These elements are somewhat different in the actual implementation, which we’re working out now. It’s coming along slowly but is starting to actually LOOK good as well as function well. When we’ve finished the coding tonight and tomorrow, there will be more accurate screencaps to share!

Because so much of the interface involves dynamically generating elements of the interface based on who is logged in to the system and what data is most recent, we decided to start with a one of the most basic and difficult elements of the interface: the timeline. For every rehearsal displayed by the interface, there is a timeline generated to display which actors are onstage at particular times, as well as where notes were taken on their performances. To work with this, we started from scratch, building a number of original classes (ie: “Rehearsal”, “Person”, “Timeline”, “Note” objects, etc) and then writing methods to dynamically generate an image.

The second aspect of the interface we chose to implements was the parsing of notes files. We have a computerized pen that will record the notes a director takes, and we need to be able to import that information into our program, creating new Note objects and assigning them to the right people and timestamps. Though the notes do not display at this point, we have been able to parse them in – very exciting.

Personally, I focused most on the design of the interface of the project, which has been one of the more disastrous aspects of this milestone. Without any data to work with, I drew up a basic interface; it was difficult, however, to visualize how it would look with an actual timeline, video, and notes. It wasn’t until last night (well, morning, really) that we finally returned from Thanksgiving break to integrate our work together, and at that point we realized we were working with a terribly ugly and confusing interface. (I think we started calling it “the ugliest interface we’ve ever made,” actually.) Currently, it looks like this in the simulator:

(We’re not sure where that grey border at the bottom is from, why the interface doesn’t fit on the screen, or why some notes are black. Debugging will be fun!)

So! For the next deadline, we’ve decided to overhaul the interface. One of the biggest hurdles to get past is making our interaction workspaces show up in ScatterView panels, which are able to be moved around the Surface with gestural interaction. I will be reorganizing this main interaction space into a smaller ScatterView panel, as well as designing a smaller “Recent Notes” panel and a singular “Note” panel so that users can pull a note from the list to view individually. Hopefully, this will make the application easier to use, more collaborative, and more aesthetically pleasing. Everything needs to be resdesigned before we can continue to program interactions though, so we’ll be jumping in to the design tonight. We’ll also be filming a rehearsal tonight (of the show I’m working on, Gibraltar, which opens Thursday) so that we can have some accurate, useful source material for our final presentation.

Overall, the programming and design of the project have both been difficult; I think every member of our team is struggling at every turn. We have made huge amounts of progress since our paper prototype, though, so I have hope that we will be able to both fix the problems we’re facing and continue to implement more interactivity. I’m excited to see how the next two weeks go, and I’m also excited to see more progress on the projects other groups are working on, for everyone’s presentations on their functional prototypes were great!

In the end, we decided to simplify the interaction by synchronizing the responses to an interaction of every element on screen. There are three main points of interaction, and each one has the same result. A user can move a highlighted bracket across the main timeline, slide through the expanded timeline, or scroll through the panel of notes. At any of these interactions, the surface comes back with the same response: the highlight on the main bracket moves, the expanded timeline scrolls, the notes scroll, and the video clip moves to a new section. Hopefully, synchronizing these elements should simplify the program and the user experience.

Outside of those interactions, there are only a few other main workspace interactions to deal with: deleting and sorting notes. We’ll be working with these main workspace interactions this week as we move into our horizontal and vertical implementations in C#.