Standard Issue:

(1) Real Estate [Days]
(2) The Weeknd [House of Balloons]
(3) tUnE-yArDs [w h o k i l l]
(4) SBTRKT [SBTRKT]
(5) The Field [Looping State of Mind]
(6) Cults [Go Outside]
(7) Neon Indian [Era Extrana]
(8) Washed Out [Within and Without]
(9) Starfucker [Reptilians]
(10) Royal Headache [Royal Headache]

Honorable Mention:

Star Slinger [Fabric Mix April 2011]
Purity Ring [Ungirthed 7"]
Shabazz Palaces [Black Up]
Tycho [Dive]
Cut Copy [Zonoscope]

Albums that I only really started listening to this year, but came out sometime before then:

Steve Reich [Music for 18 Musicians]
Toro y Moi [Causers Of This]
The Clean [Mixotheque NZ Vol. 1: Tally Ho!]
Richard Wagner [Wilhelm Furtwängler dirige Richard Wagner]
Small Black [New Chain]

From there you want to get:

• devdriver_4.0_linux_64_270.41.19.run
• cudatoolkit_4.0.17_linux_64_ubuntu10.10.run
• gpucomputingsdk_4.0.17_linux.run

# turn off X
sudo stop gdm

# uninstall any previously installed Nvidia drivers
sudo apt-get --purge remove nvidia-*

# make all the installers executable
chmod +x ~/Downloads/*.run

# run the driver installer
sudo ~/Downloads/devdriver_4.0_linux_64_270.41.19.run

# reboot
sudo reboot

# install dependencies
sudo apt-get install libxi-dev libxmu-dev freeglut3-dev gcc-4.4 g++-4.4 build-essential

# install toolkit
sudo ~/Downloads/\
 cudatoolkit_4.0.17_linux_64_ubuntu10.10.run

# install SDK
sudo ~/Downloads/gpucomputingsdk_4.0.17_linux.run

# I use /opt/NVIDIA_GPU_Computing_SDK because
# I like my home directory uncluttered

# Set path variables
export PATH=$PATH:/usr/local/cuda/bin
# 32-bit would use lib instead of lib64
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/lib
# You probably want to append these to your .bashrc if you use cuda frequently

# install gcc 4.4 into a directory for nvcc to use
sudo mkdir /opt/gcc44
sudo ln -s /usr/bin/cpp-4.4 /opt/gcc44/cpp
sudo ln -s /usr/bin/gcc-4.4 /opt/gcc44/gcc
sudo ln -s /usr/bin/g++-4.4 /opt/gcc44/g++

# modify cuda to use this gcc 4.4 installation
sudo bash -c "echo 'compiler-bindir = /opt/gcc44' >> /usr/local/cuda/bin/nvcc.profile"

# Make the SDK examples
cd /opt/NVIDIA_GPU_Computing_SDK
sudo chown -R [username] .
make

# Try out an example
./C/bin/linux/release/smokeParticles

# Before running make you first need to do the following:

# sudo port install vxl gtkmm
# svn co https://opengazer.svn.sourceforge.net\
# /svnroot/opengazer

VXLLIB = /opt/local/lib/vxl/
VERSION = opengazer-0.1.2
CPPFLAGS = -Wall -g -O3
LINKER = -L$(VXLLIB) -L/opt/local/lib -lm -ldl -lvnl -lmvl -lvnl_algo -lvgl -lgthread-2.0 

INCLUDES = -L/opt/local/lib/vxl/ -I{/usr/local/include,/opt/local/include/vxl}{,/core,/vcl,/contrib/oxl}

sources = opengazer.cpp Calibrator.cpp GazeTrackerGtk.cpp HeadTracker.cpp LeastSquares.cpp EyeExtractor.cpp GazeTracker.cpp MainGazeTracker.cpp OutputMethods.cpp PointTracker.cpp FaceDetector.cpp GazeArea.cpp TrackingSystem.cpp GtkStore.cpp Containers.cpp GraphicalPointer.cpp Point.cpp utils.cpp BlinkDetector.cpp FeatureDetector.cpp Alert.cpp 

objects = $(patsubst %.cpp,%.o,$(sources))

%.o.depends: %.cpp
	g++ -MM $< > $@

%.o: %.cpp 
	g++ -c $(CPPFLAGS) -o $@ `pkg-config cairomm-1.0 opencv gtkmm-2.4 --cflags` $(INCLUDES) $< 

opengazer: 	$(objects)
	g++ $(CPPFLAGS) -o $@ `pkg-config cairomm-1.0 opencv gtkmm-2.4 --libs`  $(LINKER) $^

include $(patsubst %.cpp,%.o.depends,$(sources))

TAGS: always
	etags *.cpp *.h

ship: always
	mkdir $(VERSION) || rm -fr $(VERSION)/*
	cp LICENSE README Makefile calpoints.txt haarcascade_frontalface_alt.xml $$(for file in $$(cat $(addsuffix .depends,$(objects))) ; do test -f $$file && echo $$file ; done | sort -u) $(VERSION)/
	tar czf $(VERSION).tar.gz $(VERSION)
	cp $(VERSION).tar.gz README /home/ftp/pub/www/opengazer/

.PHONY: always ship

clean:
	rm -rf opengazer
	rm -rf *.o
	rm -rf *.o.depends

Working with Gunnar Green of TheGreenEyl, we took the PDFs supplied by workshop participants and reworked the text and layout using InDesign 5. While InDesign can “generate” an index, it actually needs a set of keywords. InDesign really just renders the index and isn’t smart enough to figure out what words should be included.

At this point I did a bit of research into what is available for index generation. Over on MetaFilter you drop in to an informative thread about the variety of options. You might want to hire a professional indexer or pay for some software. But if you are like me you might start to view index generation as a very simple pattern recognition problem.

What follows are some building blocks for index generation written in Python and using nltk. I used them to generate an index for the multi-author workshop proceedings book mentioned above. The instructions assume you have Python and nltk installed on your computer.

Step 1:

Get your text into plaintext format with a decent encoding. I’d recommend UTF-8 as it has good unicode support. For convenience I’ve named this plaintext file “book.txt”.

Step 2:

Start simple by just making a histogram of the words appearing in the text. I wanted to just make a CSV file that I could open in Excel, Numbers, Mathematica or R. After looking over the most frequently occurring words, I was able to manually screen out parts of speech, punctuation and find the words which were meaningful to my book.

The following code opens up a file book.txt and prints out a comma-seperated list consisting of the term frequency and the term itself:

import nltk
from nltk import word_tokenize
import operator
from collections import defaultdict

text = open('book.txt').read()
words = word_tokenize(text)

# improvement due to patch by Paul Masurel
frequencies = defaultdict(int)

for w in words:
    frequencies[w] += 1

# sort the list before printing
for word, freq in sorted(frequencies.iteritems(), key=operator.itemgetter(1)):
    print str(freq) + "," + word

Step 3:

Looking over a typical book, one quickly realizes that a hefty part of a good index consists in multiple word phrases. And so I also built some programs to identify the most frequently occurring pairs of words (also known as bigrams):

import nltk
from nltk.collocations import *
from nltk.probability import *
from nltk import word_tokenize

from collections import defaultdict

text=open('book.txt').read()
words = word_tokenize(text)

bigram_measures = nltk.collocations.BigramAssocMeasures()
finder = BigramCollocationFinder.from_words(words)
finder.apply_freq_filter(3)

print finder.nbest(bigram_measures.pmi, 50)

A program to find trigrams is quite similar:

from nltk.collocations import *
from nltk.probability import *
from nltk import word_tokenize

text=open('book.txt').read()
words = word_tokenize(text)

trigram_measures = nltk.collocations.TrigramAssocMeasures()
finder = TrigramCollocationFinder.from_words(words)
finder.apply_freq_filter(2)

print finder.nbest(trigram_measures.pmi, 50)

Step 4:

Combining the output of Steps 2 and 3 I created a list of 1-3 word keywords.  Were I not in such a rush to get the book to press I might have paused to make output format of the bigram and trigram code similar to the CSV file, but I found that I only used a small number of phrases from this analysis which was easy enough to copy by hand. I then in my spreadsheet program whittled these lists down to a final index list which can be sorted alphabetically. If you’d rather not use a a spreadsheet the following script can alphabetize for you:

#!/usr/bin/python

import sys

if len(sys.argv) < 3:
    print "usage: alphabetize.py [input filename] [output filename]"
    exit(-1)

inputFile = open(sys.argv[1], "r")
outputFile = open(sys.argv[2], "w")

for line in sorted(inputFile, key = str.lower):
    outputFile.write(line)   

While these tools are a bit primitive, they do give you a bit more insight into how the index itself is built and thus allow you make your own decisions about what will be indexed. Think of them as helper tools to narrow down the list of candidates you might want to include based on frequency.

Suppose you want to have a new window title for a notebook you get from someone else or the Wolfram Demonstration Project. You started with another person’s code, but you’ve spent a lot of time modifying it and now it describes something entirely different. Before you try it, I’ll tell you that editing the notebooks with “Internal cache information” in a text editor is punished with infuriating warning messages and doesn’t work without further hacking.

Now that I’ve vented my spleen, here is a workaround to re-title the notebook it is pasted into:

SetOptions[EvaluationNotebook[], WindowTitle -> "Your Title Here"]

So here I provide some rough notes for the process of running Ace of Spades 0.36 on Macintosh computers through Wine:

1. Install macports. At present this requires downloading Xcode 3.2.6 first and then grabbing the macports installer. You can find instructions on the macports site.
2. Open a terminal and install wine via macports with the following command. Beware that building wine is a lengthy process and took around 4~6 hours in my case.

sudo port install wine

3. Reconfigure wine to use a virtual desktop. The exact size seems to vary from system to system but 1024 x 768 seems to work on 2010 Macbook Airs and 800 x 600 works on 2007 Macbook Pros. You can accomplish this by running winecfg from the terminal. It may take some time to launch wine so be a little patient. When it does, click the graphics tab, select emulate a virtual desktop and set it to be 800×600 or 1024×768

winecfg

4. Download the Ace of Spades installer from Ben Aksoy’s site.
5. Use wine to run the installer.

wine msiexec /i ~/Downloads/aos036install.msi

6. Once it is installed you can play AoS using the following command if you have a server address

wine ~/.wine/drive_c/Program\ Files/Ace\ of\ Spades/client.exe -aos://432934936

7. You can find aos:// addresses over on the Ace of Spades server listing. Just control-click on one of the game names and copy its link address. Paste the link into the terminal for your wine command replacing PASTE_LINK_HERE in the example below:

wine ~/.wine/drive_c/Program\ Files/Ace\ of\ Spades/client.exe -PASTE_LINK_HERE

It is a bit of lengthy process but is really worth all the mayhem and ingenuity happening in the AoS block worlds. Danger: for weekends and vacation time only.


]]> http://sublimated.wordpress.com/2011/05/01/ace-of-spades-on-os-x/feed/ 0 fool http://sublimated.wordpress.com/2011/03/25/installing-cuda-4-0-rc-on-ubuntu-10-10-64-bit/ http://sublimated.wordpress.com/2011/03/25/installing-cuda-4-0-rc-on-ubuntu-10-10-64-bit/#comments Fri, 25 Mar 2011 08:39:25 +0000 Carson Reynolds http://sublimated.wordpress.com/?p=331 ]]> Here are some rough notes describing my steps to get Cuda 4.0 installed and the SDK samples built on Ubuntu 10.10 (Maverick Meerkat) 64-bit. At present you need an Nvidia developer account and once you’ve signed up for one you can download the Cuda 4.0 RC.

From there you want to get:

• devdriver_4.0_linux_32_270.35.run
• cudatoolkit_4.0.11_linux_64_ubuntu10.10.run
• gpucomputingsdk_4.0.11_linux.run

# turn off X
sudo stop gdm

# uninstall any previously installed Nvidia drivers
sudo apt-get --purge remove nvidia-*

# make all the installers executable
chmod +x ~/Downloads/*.run

# run the driver installer
sudo ~/Downloads/devdriver_4.0_linux_64_270.35.run

# reboot
sudo reboot

# install dependencies
sudo apt-get install libxi-dev libxmu-dev freeglut3-dev gcc g++ build-essential

# install toolkit
sudo ~/Downloads/cudatoolkit_4.0.11_linux_64_ubuntu10.10.run

# install SDK
sudo ~/Downloads/gpucomputingsdk_4.0.11_linux.run

# I use /opt/NVIDIA_GPU_Computing_SDK because
# I like my home directory uncluttered

# Set path variables
export PATH=$PATH:/usr/local/cuda/bin
# 32-bit would use lib instead of lib64
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/usr/lib
# You might want to append these to your .bashrc if you use cuda frequently

# Make the SDK examples
cd /opt/NVIDIA_GPU_Computing_SDK
sudo chown [username] .
make

# Try out an example
./C/bin/linux/release/particles


]]> http://sublimated.wordpress.com/2011/03/25/installing-cuda-4-0-rc-on-ubuntu-10-10-64-bit/feed/ 6 fool http://sublimated.wordpress.com/2011/03/22/making-cvcalccovarmatrix-act-like-matlab/ http://sublimated.wordpress.com/2011/03/22/making-cvcalccovarmatrix-act-like-matlab/#comments Tue, 22 Mar 2011 12:04:44 +0000 Carson Reynolds http://sublimated.wordpress.com/?p=324 ]]> For an online Mahalanobis distance calculator, Connsynn set out to use OpenCV’s built in functions. However to her surprise there were few good examples of computing covariance matrices with OpenCV and fewer whose results matched MATLAB and Mathematica’s output. Just to save other folks the trouble, below is a quick test program. You can verify that its results match WolframAlpha’s for Covariance[{{38, 55, 49},{43, 54, 4}}]

#include <iostream>
#include <fstream>
#include <cv.h>
#include <highgui.h>

using namespace std;
using namespace cv; 

// OpenCV Covariance Example
// Chye Connsynn and Carson Reynolds March 23, 2011
// An example that computes a covariance matrix
// Tested using OpenCV 2.2 on OS X 10.6.7

int main( int argc, char** argv ) {
  // Input matrix size
  const int rows = 2;
  const int cols = 3;  

  // Input matrix
  float x[rows][cols] = {{38, 55, 49},
			 {43, 54, 4}};

  // Place input into CvMat**
  CvMat** input = new CvMat*[rows];		
  for(int i=0; i<rows; i++) {
    input[i] = cvCreateMat(1, cols, CV_32FC1);
    for(int j=0; j<cols; j++) {
      cvmSet(input[i], 0, j, x[i][j]);
    }
  }

  // Covariance matrix is N x N,
  // where N is input matrix column size
  const int n = cols;

  // Output variables passed by reference
  CvMat* output = cvCreateMat(n, n, CV_32FC1);
  CvMat* meanvec = cvCreateMat(1, rows, CV_32FC1);

  // Calculate covariance matrix
  cvCalcCovarMatrix((const void **) input, \
		    rows, output, meanvec, CV_COVAR_NORMAL);

  //Show result
  cout << "Covariance matrix:" << endl;
  for(int i=0; i<n; i++) {
    for(int j=0; j<n; j++) {
      cout << "(" << i << "," << j << "): ";
      // normalize by n - 1 so that results are the same 
      // as MATLAB's cov() and Mathematica's Covariance[] do
      printf ("%f ", cvGetReal2D(output,i,j) / (rows - 1));
      cout << "\t";
    }
    cout << endl;      
  }
  return(0);
}


]]> http://sublimated.wordpress.com/2011/03/22/making-cvcalccovarmatrix-act-like-matlab/feed/ 3 fool http://sublimated.wordpress.com/2011/02/19/command-line-processor-and-bandwidt/ http://sublimated.wordpress.com/2011/02/19/command-line-processor-and-bandwidt/#comments Sat, 19 Feb 2011 21:01:36 +0000 Carson Reynolds http://sublimated.wordpress.com/?p=318 ]]> Now that I have started working with some custom Linux kernels for the Gumstix Overo, I find I often need to keep a build machine churning. This wouldn’t really go smoothly without the following small command-line tools:
screen: allows me to disconnect and reconnect to a running process
htop: visually displays processor utilization
iftop: same as the above, but for bandwidth instead

Recombining the above, you can keep a remote computer busily working and look at a glance at how your build is progressing.


]]> http://sublimated.wordpress.com/2011/02/19/command-line-processor-and-bandwidt/feed/ 0 fool http://sublimated.wordpress.com/2011/02/17/benchmarking-frames-per-second-when-using-opencvs-cvcapturefromcam/ http://sublimated.wordpress.com/2011/02/17/benchmarking-frames-per-second-when-using-opencvs-cvcapturefromcam/#comments Thu, 17 Feb 2011 21:33:25 +0000 Carson Reynolds http://sublimated.wordpress.com/2011/02/17/benchmarking-frames-per-second-when-using-opencvs-cvcapturefromcam/ ]]> I find myself benchmarking a lot of cameras these days. Oddly, the OpenCV stuff (e.g. CV_CAP_PROP_POS_MSEC) which you’d tend to use seems to work well for recorded video files but not live capture. But no matter, an FPS meter is a trivial undertaking:

#include <cv.h>    
#include <highgui.h>

#include <time.h>
#include <stdio.h>

using namespace std;

int main(int argc, char** argv)
{
  // OpenCV Capture object to grab frames
  CvCapture *capture = cvCaptureFromCAM(0);

  // start and end times
  time_t start, end;

  // fps calculated using number of frames / seconds
  double fps;

  // frame counter
  int counter = 0;

  // floating point seconds elapsed since start
  double sec;

  // start the clock
  time(&start);
  
  while(cvGrabFrame(capture))
    {
      // grab a frame
      IplImage *frame = cvRetrieveFrame(capture);

      // see how much time has elapsed
      time(&end);

      // calculate current FPS
      ++counter;		
      sec = difftime (end, start);      
      
      fps = counter / sec;

      // will print out Inf until sec is greater than 0
      printf("FPS = %.2f\n", fps);
    }
	
  cvReleaseCapture(&capture);
  return 0;
}

Maybe Connsynn will find this an interesting alternative to her FPS calculation approach?


]]> http://sublimated.wordpress.com/2011/02/17/benchmarking-frames-per-second-when-using-opencvs-cvcapturefromcam/feed/ 1 fool