Dominik Moritz

Applying for a PhD

2024-11-20T00:00:00+00:00

Here is my n=1 perspective on applying for a PhD in computer science at a research University. I think a PhD is awesome. It allows you to grow into a world-class researcher, push the boundaries of human knowledge, and connect with an international research community.

If you want to do a PhD with me—awesome—please apply to the HCII at CMU. I am looking forward to your application especially if you are from a non-traditional background! If you are curious about some general background on a PhD, read this comprehensive summary. If you email me about your application, note that I may be unable to respond.

The PhD application process at top CS departments is highly competitive so it may help you to understand what I am prioritizing. Professor Eugene Wu has written about goal-oriented applications. The point I want to highlight is that your research statement should not be about what you have done or how my research interests you. It should provide evidence that you can do research in my lab and convince me that you can maximize our research impact compared to other candidates. In practical terms, this means showing evidence of research potential (e.g., publications, research experience), describing a research vision, and getting strong recommendation letters. Professor Mike Ernst has great advice on applying to grad school.

Make sure you understand the admission process which differs between universities. For example, at the HCII, the department rather than the individual faculty decides on admission. Individual faculty still have a say in the admission so make sure to mention them in your application. You can learn more about how the HCII process works.

Professor Lace Padilla has a great YouTube series on how to prepare an application and thrive in academia. Other faculty will have their own advice.

There is a lot of advice once you are in a PhD program on how to become a successful researcher but that’s for another day.

Scanning Photo Albums

2021-01-28T00:00:00+00:00

As a millennial, most of my childhood is not recorded in digital photos but in videos on VHS tapes and photos albums that my parents have. I like flipping through digital photos and so I decided that it’s time to get all the pictures into digital form. Now the question is how? In this post I am showing that a simple flatbed scanner and some open source command line tools (Fred’s ImageMagick Scripts, ImageMagick/GraphicsMagick, Parallel, Exiftool, and standard UNIX tools) are fast and produce good quality images.

Photo scanner apps are not good enough

My first idea was to use the good camera on my phone. I have seen apps such as Google Photo Scan that promise to avoid glare and other artifacts that you get if you just took a photo. I tried a few apps but none of them worked. It takes forever to scan a single photo, there are artifacts on the images, and since pictures are not flat, the scans often come out distorted.

Scanning and segmenting images with Image Capture almost worked

My next idea was to use the flatbed scanner we already have in our multifunction printer. The scans are actually really good. The problem is that I don’t want to crop all images by hand. I have a mac and the Image Capture app (which already comes with macOS) has a decent cropping function. However, it uses the scanner preview (scanners typically show you a quick preview, then you decide which region to scan, and then they scan the selected region). The preview often isn’t good enough to properly segment the image so I decided to build my own segmentation pipeline with some open source tools.

A pipeline for scanning and segmenting dozens of photo albums

The following pipeline worked well for us. In short, we scan full pages, crop them with multicrop, then convert them to JPEG, and set the correct dates.

First, we put as many pictures on the flatbed scanner as we can fit. Ideally, they are ordered from top-right, over to the left, to the bottom left when you put them on the scanner. This way they are in the correct order in the scanned image. Now, we scan the full page in 600 DPI (that’s my scanner’s max and it worked well) as TIFF. Scanning the full page means we don’t need a preview and can go through a photo album in half an hour.

Now we have a folder full of scans such as this one scan.

Note that all scans have the name Combi_{}.tiff. The rest of my scripts assume this name and so if you follow this post, make sure to set the right name in Image Capture.

The next step is to segment the images. Fred’s ImageMagick Scripts are really good for this task. I downloaded and installed (copied into my path and made them executable) the multicrop, unrotate, and autotrim scripts. To avoid problems with spaces, I first replace all spaces with _.

find . -type f -name "*.tiff" -exec rename "s/\s/_/g" {} \;

Then I crop images with Multicrop, which is documented here. I don’t want to process the images one by one so I use GNU parallel to run 6 processes at the same time (might be different for you).

find . -name "*.tiff" | parallel -j 6 --eta -q multicrop -c 50,50 -u 2 -m save -i yes {} {/.}_split.tiff

-c 50,50 says where to find the background color for segmentation. 50 pixels off the top right corner worked well for me. -u 2 uses a slightly better (but slower) algorithm to detect rotations. -m save saves the mask (for debugging purposes). -i yes trims the segmented images a bit so that we don’t get a white border.

Multicrop runs some algorithms to find a mask such as this one.

Don’t worry if the masks are not perfect. Multicrop then uses the mask to find the images to segment and outputs segmented images such as these four.

Multicrop takes a while to process images so you can grab a beverage of your choice while your computer is hard at work (such as mine was as you can see below).

Fixing orientation and converting to JPEG

Now we have nicely segmented images but they are often incorrectly rotated, are still TIFFs, and they have the wrong dates. I corrected the orientation manually in Finder.

Rotating images with Finder doesn’t always reliably rotate the images after processing so I had to apply the orientation change to the images. To do this and to then convert all images to JPEGs, I used GraphicsMagick (ImageMagick also works).

gm mogrify -auto-orient *_split-*.tiff
gm mogrify -format jpg -quality 90% *_split-*.tiff

Correcting dates

Next, I wanted to have correct dates in the images. However, I also wanted the images to have the correct order when I look at them in e.g. Apple Photos. My idea was to set the dates of the image to the correct date and to use the time to sort them correctly. To set the right time, I set it based on the file names (which are in the correct order).

But first I made a folder for each set of images that I wanted to have the same date.

My files are Combi_{i}_split-{sss}.{tiff,jpg} where i is a sequence number (e.g. 0, 12, or 32) and sss is a three digit number that identifies an image inside a scan. I set the minutes to i (by adding a leading 0 if needed and subtracting a start value so I don’t go over 59) and seconds to s. I assume that there are at most 8 images per scan and that there are at most 59 scans. Since I put all scans that should have the same date into one folder, this limitation hasn’t been a problem.

I created the following bash script, which I called setdatetimeoriginal and put it in my path. It uses Exiftool to set the DateTimeOriginal EXIF property as described above.

#!/usr/bin/env bash

set -e

start=$1
end=$2
date=$3

for m in $(seq $start $end)
do
    echo "Setting dates for Combi_${m}_split-00*.*"
    minutes=$(printf "%02d" $(($m-$start)))
    for s in $(seq 0 8)
    do
        file=Combi_${m}_split-00${s}
        if test -f "${file}.tiff"; then
            exiftool '-datetimeoriginal='"${date}"' 12:'"${minutes}"':'0"${s}"'' -overwrite_original ${file}*
        fi
    done
done

Now, I can run setdatetimeoriginal 27 32 1990:10:15 to set the dates and order (by time) of all images in a folder. The output of the script looks something like this.

Setting dates for Combi_27_split-00*.*
image files updated
image files updated
image files updated
image files updated
Setting dates for Combi_28_split-00*.*
image files updated
image files updated

That’s it. I am really happy with the results. I was especially impressed with the quality of the segmentations and hope that you find this post useful if you want to scan your family photos.

Draco: Representing, Applying & Learning Visualization Design

2018-10-22T00:00:00+00:00

Jeff and I wrote a blog post about Draco.

How fast is fast enough?

2018-09-11T00:00:00+00:00

To support effective exploration, visualization systems need to be fast. Liu and Heer showed in their paper that an additional latency of 500ms negatively affects the user’s behavior. They even found that the negative effects continue even after the delay is removed. Unfortunately, some system designers misunderstood the 500ms as a threshold that should be met. However, the paper only talks about the difference of low vs high latency and the goal should be low-latency.

The paper also found that some interactions are more latency sensitive than others. For example, zooming is not as latency sensitive as panning. Sending a query through a form should return results quickly but 60fps (16ms) is probably not quite necessary. So when you are designing a system, what latency should you aim for? Until we have further evidence for particular thresholds, we could use a guideline.

As a rule of thumb, I am proposing that we require that latency should be lower than the shortest time between any two user queries. This rule is motivated by the fact that responses arrive before the user can send the next query. As an extreme example, in crossfiltering every movement of the brush fires a new query and delayed responses would display outdated information.

I think this rule could provide a reasonable upper bound but not necessarily a lower bound. For example, just because it takes me a ten seconds to write a search query on Google, I would not want to wait ten seconds.

Value-Suppressing Uncertainty Palettes

2018-06-19T00:00:00+00:00

Michael, Jeff and I wrote a blog post about VSUPs.

Introducing Vega-Lite 2.0

2017-10-31T00:00:00+00:00

Ham, Arvind, Jeff and I wrote a blog post about the release of Vega-Lite 2.

Simple Sudoku Solver

2016-08-23T00:00:00+00:00

I implemented a simple Sudoku solver to showcase forward checking and answer a Stack Overflow question.

import sys
from copy import deepcopy


def output(a):
    sys.stdout.write(str(a))


N = 9

# just need propagation
# field = [
#     [5, 1, 7, 6, 0, 0, 0, 3, 4],
#     [2, 8, 9, 0, 0, 4, 0, 0, 0],
#     [3, 4, 6, 2, 0, 5, 0, 9, 0],
#     [6, 0, 2, 0, 0, 0, 0, 1, 0],
#     [0, 3, 8, 0, 0, 6, 0, 4, 7],
#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
#     [0, 9, 0, 0, 0, 0, 0, 7, 8],
#     [7, 0, 3, 4, 0, 0, 5, 6, 0],
#     [0, 0, 0, 0, 0, 0, 0, 0, 0],
# ]

# less constrained example
# field = [
#     [0, 0, 0, 0, 0, 0, 0, 1, 2],
#     [0, 0, 0, 0, 3, 5, 0, 0, 0],
#     [0, 0, 0, 6, 0, 0, 0, 7, 0],
#     [7, 0, 0, 0, 0, 0, 3, 0, 0],
#     [0, 0, 0, 4, 0, 0, 8, 0, 0],
#     [1, 0, 0, 0, 0, 0, 0, 0, 0],
#     [0, 0, 0, 1, 2, 0, 0, 0, 0],
#     [0, 8, 0, 0, 0, 0, 0, 4, 0],
#     [0, 5, 0, 0, 0, 0, 6, 0, 0],
# ]

# world's hardest sudoku
# http://www.telegraph.co.uk/news/science/science-news/9359579/Worlds-hardest-sudoku-can-you-crack-it.html
field = [
    [8, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 3, 6, 0, 0, 0, 0, 0],
    [0, 7, 0, 0, 9, 0, 2, 0, 0],
    [0, 5, 0, 0, 0, 7, 0, 0, 0],
    [0, 0, 0, 0, 4, 5, 7, 0, 0],
    [0, 0, 0, 1, 0, 0, 0, 3, 0],
    [0, 0, 1, 0, 0, 0, 0, 6, 8],
    [0, 0, 8, 5, 0, 0, 0, 1, 0],
    [0, 9, 0, 0, 0, 0, 4, 0, 0],
]


def print_field(field):
    """ Print a sudoku field. """
    for i in range(N):
        for j in range(N):
            cell = field[i][j]
            if cell == 0 or isinstance(cell, set):
                output(".")
            else:
                output(cell)
            if (j + 1) % 3 == 0 and j < 8:
                output(" |")

            if j != 8:
                output(" ")
        output("\n")
        if (i + 1) % 3 == 0 and i < 8:
            output("- - - + - - - + - - -\n")


def read(field):
    """ Read field into state (replace 0/None with set of possible values). """

    state = deepcopy(field)
    for i in range(N):
        for j in range(N):
            cell = state[i][j]
            if cell == 0 or cell == None:
                state[i][j] = set(range(1, 10))

    return state


state = read(field)


def done(state):
    """ Are we done? """

    for row in state:
        for cell in row:
            if isinstance(cell, set):
                return False
    return True


def propagate_step(state):
    """
    Propagate one step.
    
    @return:  A two-tuple that says whether the configuration is solvable and whether the propagation changed the state.
    """

    new_units = False

    # propagate row rule
    for i in range(N):
        row = state[i]
        values = set([x for x in row if not isinstance(x, set)])
        for j in range(N):
            if isinstance(state[i][j], set):
                state[i][j] -= values
                if len(state[i][j]) == 1:
                    val = state[i][j].pop()
                    state[i][j] = val
                    values.add(val)
                    new_units = True
                elif len(state[i][j]) == 0:
                    return False, None

    # propagate column rule
    for j in range(N):
        column = [state[x][j] for x in range(N)]
        values = set([x for x in column if not isinstance(x, set)])
        for i in range(N):
            if isinstance(state[i][j], set):
                state[i][j] -= values
                if len(state[i][j]) == 1:
                    val = state[i][j].pop()
                    state[i][j] = val
                    values.add(val)
                    new_units = True
                elif len(state[i][j]) == 0:
                    return False, None

    # propagate cell rule
    for x in range(3):
        for y in range(3):
            values = set()
            for i in range(3 * x, 3 * x + 3):
                for j in range(3 * y, 3 * y + 3):
                    cell = state[i][j]
                    if not isinstance(cell, set):
                        values.add(cell)
            for i in range(3 * x, 3 * x + 3):
                for j in range(3 * y, 3 * y + 3):
                    if isinstance(state[i][j], set):
                        state[i][j] -= values
                        if len(state[i][j]) == 1:
                            val = state[i][j].pop()
                            state[i][j] = val
                            values.add(val)
                            new_units = True
                        elif len(state[i][j]) == 0:
                            return False, None

    return True, new_units


def propagate(state):
    """ Propagate until we reach a fixpoint. """
    while True:
        solvable, new_unit = propagate_step(state)
        if not solvable:
            return False
        if not new_unit:
            return True


def solve(state):
    """ Solve sudoku """

    solvable = propagate(state)

    if not solvable:
        return None

    if done(state):
        return state

    for i in range(N):
        for j in range(N):
            cell = state[i][j]
            if isinstance(cell, set):
                for value in cell:
                    new_state = deepcopy(state)
                    new_state[i][j] = value
                    solved = solve(new_state)
                    if solved is not None:
                        return solved
                return None


print_field(solve(state))

Introducing Vega-Lite

2016-02-23T00:00:00+00:00

Ham, Jeff and I wrote a blog post to announce Vega-Lite.

Code retreats improve coding abilities

2014-09-29T23:55:44+00:00

This summer, I was at Google in NYC for an awesome internship. However, in this post I want to talk about a Code Retreat that somebody at Google organized. The idea is simple: Pair up a bunch of programmers and give them a simple programming task that they can solve as a pair in any language but with a time constraint. Repeat this for a whole day for maximum fun. Each iteration may add additional constraints on how the team should work together or what programming constructs they are allowed to use. It’s a great opportunity to learn from each other and from the experience of solving the same problem over and over again and bringing your program to perfection.

We used Conway’s Game of Life throughout the day and I’ve grown to like it a lot. I just wanted to share my simple implementation in Python and my first program in Go.

Update: I have since implement the Game of Live in Rust and C# and might add more in the future. The code is on GitHub.

Data visualizations

2014-03-24T06:50:21+00:00

During the spring quarter at UW, I took Jeffrey Heer’s data visualization class. As part of this class, I worked on three assignments and a final project of which I would like to share the first two assignments.

In the first assignment we had to design a visualization for Burtin’s antibiotics dataset. The task was to design a visualization without any knowledge from the class. Here is what I created:

I created the static visualization with D3. The code is on GitHub.

For the second assignment, we could choose between different datasets to visualize. I chose the FAA flight data and wanted to answer the question whether airlines overestimate the flight times in order to avoid having bad on-time records. TL;DR, the answer is yes.

The data in this plot is based on 1.4GB of flight records for one month each year since 1987. I created the plot with Tableau.

Not as part of the class but during the Open Data Day, I worked on a live map of bus locations in Seattle.