Kittenate! <– Drag this link to your bookmarks toolbar. Clicking it will replace all the images on the webpage you’re viewing with kittens. (Or you may have to right click and select ‘add bookmark’)

The Daily Puppy just got KITTENATED

To use the code you’ll need a copy of Processing. Shine a bright flashlight against your thumbnail (I used a bright LED flashlight) and place your thumb over the webcam lens so it completely blocks it. Try to hold as still as possible.  The brightness of the red channel is measured each frame and a running average is kept. If the brightness drops below the recent average, a small circle is drawn representing a contracting heart.

If it is unreliable, you may need to tweak the navg parameter and/or find a way to stabilize the light source, finger, and camera, as small shifts will cause a change in the amount of light detected by the camera.

Download the Code

You can find a demo and the source here. Click four times to set the curve points and handles. Move the mouse left and right to alter the curve tightness.

In a nutshell, the algorithm computes the approximate length of the line segment by chopping it into smaller segments and computing the linear distance between points.  Once the length of the segment is known in pixels, textWidth() is called to obtain the width in pixels of each character. This width divided by the length of the curve determines the percentage of the curve the character occupies. Once this is know, the amount to increment the variable t in the parametric curvePoint(…) function is known. From here, we can find the starting point, determine the tangent, and draw the letter.

All straightforward, right? For whatever reason, though, the kerning is severely off under certain conditions. When there is a slight curve in the line segment, it seems to be balanced. When the curve tightness is altered and becomes very flat, or very curved, the letters become overly spaced out at one end, and overly compressed at the other.  Does anyone have any suggestions as to why this is happening?

Below are a few useful tools:

Princeton’s Wordnet is a massive linguistic database containing not just definitions, but how words are related to each other.

The Python Natural Language Toolkit, which provides tools for parsing and understanding natural language semantics.

The Carnegie Mellon Pronouncing Dictionary, which breaks words down into their phonemes, providing information regarding pronouncing, rhyming, and syllable counts.

Having found no simple resource to provide syllable counts for common words, I want to share a quick solution I wrote in Python, which uses the CMU dictionary. Simply download the dictionary to the same directory as this script, naming it cmu_pron.txt.

f = open("cmu_pron.txt")

f = open("cmu_pron.txt")
lines = f.readlines()
f.close()
words = {}

for line in lines:
	pieces = line.split()
	if pieces[0] == ";;;":
		continue
	words[pieces[0]] = pieces[1:]

def num_syllables(word):
	global words
	key = word.upper()
	plist = words[key]
	return len(filter(lambda c: c in ("0","1","2"),"".join(plist)))

print "alphabet: %s" % num_syllables("alphabet")

The result for alphabet is indeed 3. There are probably more efficient ways to do this, but it gets the job done.