Some intense patch cords from a project by a current student (Jon Love).  Click the image for high-res.

John Cage playing amplified cacti… enough said.

The oldest known photograph of a tornado, taken in South Dakota in 1884.

Via: The Weather Notebook (thanks Angeles Cossio)

UPDATE:
The previous version used a Processing sketch to find the information, which seemed poetic.  However, it seems that Java doesn’t do file handling very cleanly (curse you File variable).  As I went to bed, it seemed a bash script would be much cleaner and likely faster, so I got up today and wrote one.  Sorry Windows users, this is likely Mac/Linux only.  You can still download the Processing sketch and try it yourself.

#!/bin/bash
# Jeff Thompson | www.jeffreythompson.org

# enter the year you're looking for and the path to your Processing sketchbook
lookFor="pde"											# file extension to look (period optional)
yearCreated="2011"										# year to look at
pathToCheck="/Users/jeffthompson/Documents/Processing"	# where to look
# pathToCheck=$HOME										# alternatively, look everywhere (may be VERY slow)
dateRange="01-Jan-$yearCreated"							# set date to the first of the year we're looking for

echo ""
echo "HOW MANY LINES OF CODE DID YOU WRITE THIS YEAR?"
echo -e "Path:\t\t$pathToCheck"
echo -e "Extension:\t$lookFor"
echo -e "Year:\t\t$yearCreated"

# note: we don't need the . in front of the extension since * will match all preceeding characters
find $pathToCheck -type f -name \*$lookFor -newermt "$dateRange" -and -not -newermt "$dateRange +12 month"> "$lookFor_files.txt"
fileCount=$(wc -l < "$lookFor_files.txt")

lineCount=0
charCount=0
while read line; do
	lines=$(wc -l < $line)		# count lines in the file
	let "lineCount += lines"
	chars=$(wc -c < $line)		# count characters
	let "charCount += chars"
done < "$lookFor_files.txt"

rm "$lookFor_files.txt"			 # be nice and delete the working file (optional)
echo -e "Result:\t   ${fileCount} files, ${lineCount} lines, ${charCount} characters"
exit

Max/MSP users: look familiar?

For the past week I have been wrangling with getting ffmpeg (the open-source, command line video utility) to run in a Processing sketch and preserve the hard edges of graphical and/or intentionally pixelly video. It now works!

Details are listed in the code itself, but it is most important to note that the codec is likely the most important factor in getting good quality.   The “png” codec is great, but will create rather large files; mjpeg (MotionJPEG) also works well for graphics and hard edges (pixellated images, etc); H.264 is all-around good for photgraphic images.

The sketch below runs ffmpeg’s commands within Processing (as covered before) and exports a video from a series of still files.  Processing’s built-in video library seems ok, but offers little in the way of control as compared to ffmpeg.  Questions or suggestions are welcomed – feel free to use but please give credit!

[ download the sketch here ]

Thinking about which callsign to unnoficially assign ourselves for the microbroadcasting project at Drift Station, I thought “how many possible combinations of the four-letter callsign can there be?”  The answer is 17,576 for both east (prefix of W) and west (prefix of K) of the Mississippi; the list was generated using TextMechanic.com’s great tools.

[ download the entire list as a .csv file here or as a text file (can be viewed in your browser) ]

Lots of time thinking about Voronoi Diagrams this week; click image for full-size or here for a high-res PDF.

Further experiment with Voronoi Diagrams, Processing, ffmpeg, and video (Max/MPS-ers may recognize the classic bball.mov source file).

After getting very excited about Voronoi Diagrams and this post, I took a break from PHP to make what I think is essentially a custom image-compression algorithm.  I’ve applied it to Van Gogh’s famous painting “Starry Night” at varying levels.  The program, written in Processing, essentially looks at a pixel’s neighbors and if the colors are similar enough, it sets the neighbor’s value to the tested pixel.  The above image is a allows for a difference of as much as 250 (very high compression/low similarity) and steps down in increments of 25 down to 25.

[ view the source code here ]

Via: The Office, season 6, episode 20, 12’38″