Half Hour Hacks

Periodic Table (updated)

2012-01-20T20:24:00.001-08:00

I wrote this in 2005. Back then, Internet Explorer was the only browser that could render text upside down without a browser plugin. A few years later, other browsers added their own extensions like -webkit-transform. Today I updated this old html page for cross-browser support.

Try it!

SSIP

2012-01-15T13:14:00.000-08:00

This tool will process source code and generates an index of terms. After the index is built, searches can be run very quickly, even on a large codebase. It is intended for c and c++ code, but has partial support for other languages like java and c#. The index is only for whole-string matching.

Usage

First, make a copy of ssipexample.cfg and name it ssip.cfg. Edit the file so that it points to a directory containing source code.

[main]  srcdir1=C:\path\to\my\source

Then, from a command line, one can do the following: Type sssip –s main, and you should see a result for your main() function. Full options are:

sssip -s word  Search for a word
sssip -start  Re-build index
sssip -noindex word  Search for a word without using index
sssip -noindexnowhole word  Search for a partial word without using index

If you update one of your source files, the index will notice the change and keep itself up to date.

This program is designed for speed, so it should be able to make a complete index quickly.

Download

Source and win32 binary
Source only

Measurements

I've claimed this is 'fast'. What do I mean? I downloaded the source for the Audacity audio editor, and the entire source for php 5.3.9. My test machine is a 2.67 Ghz machine I bought a year and a half ago. The test involves creating a db and indexing every file.

Test: audacity-src-1.2.6
987 source files.
9.351Mb of data indexed.
Execution time: 3.753s
Speed: 263 files/s

Test: php-5.3.9
1584 source files.
41.677Mb of data indexed.
Execution time: 6.297s
Speed: 251 files/s

Looks pretty good to me. :)

Description

I use IDEs like Eclipse and Visual Studio for debugging, but find them far too bulky for everyday programming. They are slow to open and less customizable than my code editor of choice, SciTE. However, IDEs do have some useful features, in particular Go to Definition (which takes the currently-selected symbol and opens the file and line on which it is defined). SSIP is my first step in adding features like this to code editors like SciTE.

My primary goal is speed. I want this to be usable on large codebases. I want even the initial run, creating the index from scratch, to take less than 10 seconds. Otherwise, there’s no point in generating an index, as a full-file search would be sufficient. I also found it enjoyable to optimize and tune a program, eschewing all C++ features (classes, exceptions) in favor of fast, raw, procedural code.

I struck upon a way to quickly create an index that actually does not store any text at all. I used what is known as a hash function to map every word into a number. The function always maps the same word to the same number. For example, the word ‘hello’ maps to the number 1634674. The word ‘hello2’, though, maps to a completely different number, 26453545. When the user searches for the term ‘hello’, I use the same hash function to find its corresponding number and search only for the number. This may seem too good to be true: I’ve transformed the 6 byte string ‘hello2’ into a 4 byte integer. The catch is that several inputs can map to the same number. ‘zsesdvf’, ‘rtyrqtrdg’, and ‘hello2’ could all map to the same number, 26453545. This is perfectly fine for my search index, though, because before displaying the results to the user, I’ll do a second check to make sure that the result matches what the user typed. In other words, this type of search could return false positives, but the false positives can be easily filtered out, and in the end the results are always correct.

A drawback of this method is that only full words can be searched.

The initial search creates a database from scratch. The name of each file encountered is also stored along with its last-modified time. Subsequent searches will traverse through the files again and check each file’s last-modified time. If the file is new, or its update time is more recent than what we have, we process the file and update the database.

More Implementation Details

I chose to use Sqlite to store data. By using prepared queries, the sql only had to be parsed once per session, leading to performance improvements.

I also adjusted the hash function so that it didn’t require the length of the string up front. This allowed me to stream each character into the hash, and avoid any second buffer of the current word. (In general, I’ve noticed that avoiding memory allocations and having fewer buffers can lead to significant gains in performance).

At first, I wrote a threadpool system where a main thread would hand out files to be processed by the workers. This worked, but I was surprised to see that the number of worker threads barely affected the speed of execution. Unfortunately, writing to the database was significantly slower than reading from the text file, and since sqlite only allows one writer at a time, this was a clear bottleneck. It would have been possible to create separate databases to be later merged, but this was too much of a hack even for me. I returned to single threaded execution, which did simplify the code.

At this point, the program was logging string hash, line number found, id, file id, and other flags for each word. Because the id was incrementing, I could search for two consecutive terms with a bit of sql. The other flags included whether the line was indented or not, and the surrounding characters. Surrounding characters could among other things distinguish a method implementation, like ::foo. The size of the database on disk was rather large, though.

Because writing to the database was my bottleneck, if I could store less data, the program would be faster.

I realized that my prior experience showed me that reading through a file was unexpectedly fast. So, I decided to not even store the line number in my index at all. Results saying ‘the string “hello” is somewhere in the file “foo.cpp”’ is good enough, because it takes hardly any time to run through foo.cpp to list the true results.

This also meant that I only had to record a particular string once per file. I came up with a very effective trick to rapidly detect duplicates. I was already hashing each string to a number. I reduced the number of bits in the hash to 24, probably reasonable because most words in source code are short. (Remember that in my design collisions might cause false positives that take time to be filtered out, but won’t affect correctness). This means that the number of distinct strings I was tracking was 2 to the 24th power, or 16,777,216. I then allocated a chunk of memory, 16,777,216 bytes worth to be exact. For each file I cleared all of the memory to 0, and as each string appeared I would find its hash and ‘check off’ the corresponding place in memory. I could then quickly see if a string had already been encountered in a file. (I could have also done this at the bit level, but bit operations take time, and a 24-bit hash has been sufficient). One might worry that hash collisions could cause us to incorrectly skip over a word because its brother has already been added to the db for that file, but this is not the case, because I consistently use the same hash algorithm. When searching, the program must still look through the file, because that hash did occur in that file.

The next step is for me to write a Python wrapper around Ssip that lets me ask questions like ‘find the constructor of the CFoo class’, ‘find the implementation of the bar() method’, and ‘find the type of the baz global variable’. I’ll then plug this into my code editor and be well on my way to having my own lightweight productivity toolkit.

Wavcut, Find Silence

2012-01-10T17:20:00.000-08:00

A few posts ago I wrote about wavcuthhh, the tool I wrote to split .wav files into separate tracks. I recently added the feature to look for periods of silence within a .wav file, and to cut the file based on those points. This might be useful for splitting up dj sets that consist of one huge mp3 file, or for isolating the 'hidden track' that some bands will include in the final track of an album after a minute of silence.

I use an amplitude threshold to specify what is 'silent'. The transition is not always clean, though, because songs can have a beat and the amplitude will change frequently. First, I made a large low pass filter and basically averaged the amplitude about every 0.2 seconds. To check the results, I could have written a GUI, or printed to a text file and plotted the data, but instead, went with a quick and dirty solution: writing data into another .wav file and using Audacity itself to visualize data.

The upper channel approximates the current amplitude after lpf, the lower channel indicates whether the amplitude is above or below the cutoff.

In a few cases, this was not enough, and there was still bouncing. I don't think there's a general way to solve this problem, because the silence between tracks can be the same as the silence within a track. I came up with a heuristic that has worked well so far. I assume that the first song is fading out, and the second song is fading in. Both of these might have temporary dips where the amplitude goes below the threshold, but then rises again. My algorithm goes from left to right. When encountering a drop below the threshold, I examine the next 10 seconds of audio. I look for the longest string of consecutive samples where the amplitude is below the threshold, and choose the cut location as the middle of this string. This tends to work because the pause between tracks tends to be longer than the temporary drops below the threshold during a fade-in or fade-out.

Here's what it looks like (these are ~800kb because of an example .wav):
C# source
Win32 binary

Clipcircle32

2012-01-08T22:13:00.000-08:00

Clipcircle is a Windows tool that lets you store multiple values in the clipboard at the same time and cycle between them.

Example

Run clipcircle32, and it will appear in the system tray.

Copy a word of text from any program.
Copy a different word of text.
Open notepad
Press Windows-V. (The windows key has a flag icon and is typically between Ctrl and Alt)
The word you copied appears, but is selected!
Press Windows-V again.
Now, the first word that was copied appears.

Because Clipcircle selects as well as pastes, you can quickly cycle through the contents of the circle. By default, Clipcircle stores 8 items. It intentionally only stores this many items, so that you can repeatedly press Windows-V to cycle through everything that is stored.

To close Clipcircle, press Windows-Escape.

Additional notes

The idea comes from earlier versions of Visual Studio, where pressing Ctrl+Shift+V would also go through clipboard history, but without cycling. Clipcircle, though, works with any app. I'm aware that there are other clipboard tools, but this one has my full trust. For frequently typed strings that I want to always keep around, I use the excellent Clavier+.

To customize how many items are stored, edit clipcircle.h, set g_nItems to another value, and re-build.

It's lightweight: 9Kb on disk, and only 600Kb of private working set (memory usage).

Download

If you think this might be useful, feel free to give it a whirl. I've found it to be very helpful.

Download, just unzip and run clipcircle32.
Source , GPLv3.

wavcuthhh

2011-12-23T21:06:00.000-08:00

I just wrote a little something to cut .wav files into smaller audio files. It doesn't load the whole file into memory, and so will support large files. Many other programs do this, even ffmpeg, but I wanted to write this myself, in part because I wanted to be able to specify the cutpoints very precisely (by sample number, in fact). I also wanted to be sure no audio data was lost or altered.

To confirm correct results, I wrote a simple .wav analyzer that prints information about a wav file. It confirms that information in the header is correct and outputs the riff chunks. Use the -check option to see this.

This is called WavcutHHH so that it's clearly better than any existing program called Wavcut.

WavcutHHH will split a large .wav file into several files based on a text file
that specifies cut points.

wavcut.exe input.wav input.txt

First line of the .txt file is 'wavcut'.
Remaining lines of the .txt file should be numbers, specifying where to cut.
Refer to wavcut.exe trombone.wav trombone.txt as an example.

To check wav contents, use

wavcut.exe -check input.wav

Here's what it looks like (these are ~800kb because of an example .wav):
C# source
Win32 binary

On an unrelated note, I'm still in the midst of reorganizing my music library and moving to mp4. There are more hacks in the pipeline.

Mandelbrot Set on a FPGA

2011-10-18T22:55:00.000-07:00

In April 2009, I developed an original system to compute and display the Mandelbrot set on FPGA hardware. I used the capabilities of this platform to achieve speeds of more than 25 million results computed per second.

The FPGA, or field-programmable gate array, essentially consists of a large number of logic gates that can be configured to perform computation. Developing for this platform feels foreign at first. There is no operating system, or even a CPU. Consequently, one cannot in general use a simple model where execution steps from one instruction to the next. One instead uses the fabric spatially, setting up associations and connections between components and placing logic in parallel. Making use of parallelism can lead to excellent performance solving certain problems.

I created this system on my own in my spare time, outside of class. I thank Professor Mark Chang for providing equipment and some advice.

Design

My goal was to use the unique advantages of embedded programming to make a system that can perform computations very quickly.

I chose to compute the Mandelbrot set (yes, the cliché image) on the FPGA platform, solving the problem of whether a particular x,y value was inside this set, to a given tolerance. My reasoning:

Nature of problem lends itself to parallelization
Problem involves arithmetic, has opportunities for coming up with optimization strategies.
Easy to visually verify correctness (and looks cool)

The configuration made by my design can only perform one task. A CPU, like the processor on the computer you are currently using, is general purpose, and reads from a list of instructions to perform. If given a new list of instructions, it is able to execute them. The 'program' I describe here, on the other hand, has no such list of instructions, it is physically only capable of this one task.

Like a processor, though, everything is still governed by a clock signal. In a more advanced system, the developer will divide the problem into different smaller operations that can be done per clock tick. Then, resource-expensive steps can be apportioned out (there are a limited number of hardware multipliers and other units available on the chip), and the overall clock speed can be set higher. In the design described here, though, I used a simpler approach where the same operations are done on every clock tick. While this means the system clock speed might have to be slower, it still means that during each tick of the clock, several multiplications and additions and memory reads are done at the same time -- very different than what occurs in a CPU.

I used four types of components to solve the problem. A 'Child' unit receives x,y coordinates and screen coordinates as input. It has an internal state machine. In `State_calc it performs one iteration of the Mandelbrot set computation. If the current value is too great (pixel is not in Mandelbrot set), or the number of iterations is sufficiently large (pixel is probably in Mandelbrot set), state moves to `State_write which will write the result to memory by setting a write-enable flag. `State_acqnew retrieves the next value that should be computed and resets computation. Each child had a separate RAM unit so that it could independentally read and write to memory. The 'Parent' unit contains several Child units and is responsible for dividing work among them. The current set of uncomputed values is given to the first child that is not busy. The ColorMap unit maps the number of iterations to an R,G,B color, using some shifting to unpack colors from distributed ROM. Because this isn't an art project, I just reverse-engineered and used colors from the shareware program UltraFractal. The VGA unit reads a value from memory, translates it to a color with the ColorMap unit, and sets output voltage on a physical pin. VGA scans through the image more quickly than values can be computed, which is why separate memory is required.

I could then connect these units. (I find it interesting that when on hardware, the units are literally physically connected to each other. Makes one realize that so much programming one does is very far from the hardware.) The design was intentionally flexible with regard to the number of Child units. This number can be increased until reaching the capacity of the fabric, so that my design will easily scale if a FPGA with more gates is available.

Simulation

I first made a Verilog module called vga_simulator that could be used in ModelSim. This module received r, g, and b values with the same interface as an actual vga output. It wrote to a file on disk that could later be transcribed into a standard bitmap image.

I then wrote a C implementation of the Child algorithm. Because this prototype ran quickly, I could use it to experiment with the color table, number of iterations, and initial view.

I translated my design to Verilog, using the vga_simulator to test results. I used fixed point arithmetic, which was sufficient for the problem. The product of x and y is written (x*y)>>>`FIXPTSIZE. Floating point would not have been practical for the scope of my project. I started with just one Child, and black and white, to reduce possible points of error, before slowly re-adding functionality. One obstacle was that I needed to use both signed reg and signed shift (>>>) in a certain part of my arithmetic. Coming from C, I had not realized that I needed separate syntax for signed shift, and so it took some time to realize was incorrect.

(This picture shows the result of a bug in my scheduler. Sometimes it is broken code that makes the coolest-looking results.)

With a working simulation, and a highly-visible counter that showed how many clock ticks were necessary to complete computation, I could work on optimization.

Optimization

Optimizing for this platform was a different experience than optimizing typical software. As well as taking less clock ticks to complete, the program also has to be optimized in space, to reduce the number of gates needed. This led to behavior that I did not expect: In typical software optimization, I will often check for conditions so that I can do less work if necessary, and skip going down an unneeded code path. In hardware, though, conditions are expensive, because each requires wiring. "Skipping a code path" is sometimes meaningless - the entire path is done in one clock tick anyways, and it is taking up space, so it is often better to --always-- be performing the computation, and just ignore the result if it happened to not be needed.

Straightforward optimizations included tuning constants so that iterations decreased while the image quality is still acceptable. I set up initial conditions and coordinates to values that the Parent scheduler happened to work more efficiently with. I tightened up the state machine in the child module, coming up with a way to need only two states. I rewrote the scheduler so that it did not need a barrel-shifter. For the sum of two fixed-point products, I could right-shift the sum instead of the individual products. I moved most logic to assign= statements.

I could save significant time by skipping computation inside the inner 'cardioid' shape. I soon learned, though, that multiplication was expensive due the design I chose. There were limited hardware multipliers, and I needed all children to perform at least 3 multiplies every clock tick. On the real hardware I had, there was no room for this shortcut.

Multiplication by a constant, though, I realized could be done very quickly. It was fun to re-write multiplication by 320, as n*320 == (n<<6) + (n<<8). Division by powers of 2, of course, I also converted into shifts. I aggressively re-used computed values, such as how x2 and y2 could be used in both iteration and checking magnitude. One attempt was to use an "approximation" abs(x)+abs(y) instead of the true magnitude, and to replace x2-y2 with (x+y)*(x-y), saving one multiply. This changed the visual appearance in an odd way, though.

I was pleasantly surprised to see in the logs that the Xilinx software understood that the Child module was using a state machine, it apparently could place the state reg in a more efficient way.

Implementation

Developing with simulation can be misleading. You can use as much memory as you want, and it seems perfectly fine to multiply and even divide (!) numbers with just the symbols * and /. On real hardware, RAM is limited, and in my case, hardware multipliers even more limited. One makes tradeoffs between longest chain of logic and clock speed. Also, the software for synthesis has a learning curve, and synthesizing can take a significant amount of time.

I succeeded in synthesizing the project onto the hardware available to me, a Xilinx Spartan3 XC3s1500.

To make the image look interesting, I shifted the color palette over time, making the colors move. The entire image is recomputed every time the colors shift, an intentional way of demonstrating how fast my system is. As the video above shows, the results looked great, and the refresh rate was more than sufficient.

With the limitations of the specific hardware used, my final configuration was: 4 computing children 64 colors in palette 320x240 image 25Mhz clock speed 68,024 ticks to draw one frame at standard zoom

With a larger FPGA, I could have increased the number of children to drive these numbers higher. Even still, this math brought a smile to my face: 68,024 ticks to compute 76,800 pixels 68,024 ticks @ 25Mhz to compute 76,800 pixels 0.00272096 seconds to compute 76,800 pixels 1 second to compute 28,225,332 pixels

28 million computed values per second sounds pretty nice to me.

Big Acoustic Fingerprints

2011-10-17T22:53:00.000-07:00

A few days ago, I found myself in a situation that begged for automation. As Larry Wall says, for a software developer, laziness is a virtue (good programmers will learn or invent shortcuts to save time). I had recorded many .mov files from my digital camera, and wanted to extract the audio track. I wanted to create one .mp3 file for each .mov file with its corresponding audio.

The shareware program Total Recorder, which I recommend, can record any audio played by your computer to a .wav or .mp3 file on disk. With this and Windows 7 Media Player's ability to play .mov files, I was already half-way to the solution. I could start Total Recorder, put all of the .mov files in a playlist, and wait while the audio tracks were recorded in real-time.

The result, though, would be one large .mp3 file that would have to be cut manually into pieces. For dozens of tracks, this would be a tedious process.

My first thought was to write down the list of lengths, and use that list to cut the .mp3 file. I know that the first track is 1:21, the second is 1:06, and so on. This approach, though, was prone to error. The times were rounded to the nearest second, and so by the end, errors would accumulate. Also, the Media Player itself might add slight pauses between tracks.

I then realized that I could put a 'marker' sound between each track. After recording, I could look for the markers, and split the audio precisely.

One approach to do this would be to use a generated combination of tones. I could pick a certain number of pitches that would be rare to encounter in the real audio data, and create a marker based on these frequencies. When processing afterwards, I would split the audio data into small fragments, run FFT on each fragment, and search for fragments that contained just those frequencies (allowing some margin for error). This approach would be robust to mp3 audio compression, and even playback on different speakers.

For this particular setup, though, I did not need to be as robust, because Total Recorder will record the audio digitally before it is converted to analog, although the signal is still slightly altered by mp3 compression and the operating system. As a half hour hack, I made an audio marker that has an unusual profile:

Over the course of one second, the signal value is increasing. Playing this on speakers, the sound is silent except for a click at the end when the signal suddenly drops to 0. I left the click intentionally in order to hear the sound. This is very different than a typical audio signal, which fluctuates up and down rapidly; the quick fluctuations causing an audible pitch:

It was trivial for me to find areas in the audio data where the signal value increases for more than half a second. To make the system more robust, I looked at the averages of blocks of 16 samples, and looked for long sequences where these averages were always increasing. (Note that this block size can't be safely set to a large value, because a low sound increasing in volume with DC offset could trigger false positives). After finding a match, I could skip forward several seconds, knowing that no track would be shorter than 10 seconds. It's a good thing I had my own audio library; the wav files were too big to realistically store in memory, but because I was familiar with reading raw .wav data I could just scan through the stream of bytes. My program output the cut points in milliseconds to a plain text file, adjusting the times to trim away the audio marker.

The final workflow:
1) A python script creates a .wpl Windows media player playlist of the .mov files separated by my marker audio.
2) Start Total Recorder and start the playlist, and wait for a while.
3) Save the recorded audio as .wav and run my program to determine cut points.
4) Encode as mp3.
5) I use the excellent mp3directcut to split the audio at those points. A python script turns my text file into a .cue file that mp3directcut uses to split the audio into pieces.

And that's all. The system worked very well and hit no false positives. mp3directcut can (magically?) slice up a mp3 file without recompressing, so the process is lossless and very quick. I now have an automated way to cut a long mp3 file into pieces.

Beat Circles

2011-09-22T22:22:00.001-07:00

Make beats. Tweak them by shifting each channel. Save and send to friends.

If you have Firefox, try it.

If you don't have Firefox, it looks a bit like the image above. My novel layout shows the repeating loop as an actual circular loop.

Some demo beats I came up with (but you really should put together your own):

Use the icons on the left for more adjustments:

Load a demo. Change the number of divisions, so that you can make the 7/4 beat you always wanted. A shortcut: after it is clicked, when you create a drum-hit in the upper-right quadrant, the corresponding drum-hit is also turned on in the other three quadrants.

Because the sound is generated in real time, you can edit the rhythm, and even tempo, during playback. If the volume of a channel is very high, I 'distort' the sample by intentionally causing clipping.

I made this for fun. Real software is more complicated.

Laser Sounds

2011-09-15T21:49:00.000-07:00

It's another real-time audio experiment, this one even less serious. Click the 'play' button and drag the dot across the screen to make "laser sounds".

Try it! (in a recent version of Firefox).

An example - but there are other sounds to be made that I haven't discovered yet.

Moving left to right will increase frequency, moving downwards will increase harmonic content. Moving slowly to the left with a square wave can make 90s arcade-game like noises. Increase the 'sparkle' to create even older-sounding arcade game noises.

What's going on? I am playing one tone and quickly changing the frequency. When the frequency is changed slowly, one hears a typical siren like one would expect. If the frequency is changed more quickly, the result is a "tshu" pulse sound. Finally, if the frequency is changed very quickly, the entire quality of the sound can change. This is called FM synthesis, where FM stands for frequency modulation. Radio transmitters use Frequency Modulation, changing the pitch of a single note very quickly, to 'move' a signal in frequency to a very high frequency. Video games in the 90s also used FM synthesis; when putting this program in square wave mode and moving to the left, the sound resembles that of a DOS game or GameBoy handheld. Maybe I'll follow the work of some musicians (Bibio, Crystal Castles) in incorporating arcade-like noises into music.

Tremolo Machine

2011-09-02T23:37:00.000-07:00

If you have Firefox: this is a machine that makes sounds. It's not a very serious project, but I find it entertaining. Click and drag the dots in order to move the levers, and click the play button to hear the result. (Further changes are not picked up in real time; you have to click play again.)

Try this:

Bubble music

Curious drill

Beach things

Click the eye icon for more examples (be prepared to turn down the volume).

'vib' is vibrato, causing the pitch to change pitch over time.
'trem' is tremolo, causing the sound to become quieter and louder over time.
'vib10' and 'trem10' are more potent versions of 'vib' and 'trem' (the frequency is 10 times faster).
trem10 with a high frequency can be an interesting effect. vib10 with a high frequency can in effect use frequency modulation to create another pitch.
vibc is the cooing of a bird; it plays one quarter of the vibrato and silences the rest.

The smaller control to the right of the modification type can adjust phase.

The button on the left, above the eye, will enable 'layer audio'. Now whenever you click play, you hear the previous results too, and can layer sounds upon sounds.

To make fine adjustments, click the textfield button to manually enter a value. Alternatively, click save and make adjustments to the data in the url.

Try it!
(Firefox only)

BookmarkBuckets

2011-08-06T22:57:00.000-07:00

Over the years, I have accumulated a fair number of website URLs. In one form or another, I've kept links to music videos, webcomics, essays, computational complexity blogs, artwork, and anything else that I found to be worth saving. Some of these links I organized in a OneNote web app on SkyDrive (so that it could easily be accessed from many computers). However, I wanted my own system, so that I could easily include screenshots of each page (a crucial feature for me - even if the thumbnail is too small to see content, just the color scheme can sometimes trigger one's memory of the website).

My requirements:
-Thumbnail screenshots of the webpage
-Easy to organize bookmarks into folders, not just tags
-Ability to export bookmarks and titles to simple plain-text
-Ability to sync bookmarks between machines
-Quickly navigate, rename, open, delete

My first thought was to create some non-trivial web application, maybe with some new UI concepts to browse the data. I could use a service like thumbalizr to get thumbnail. However, as Larry Wall says, for a programmer, laziness is a virtue, and I didn't want to spend very much time on what would probably be a program only I cared about. (There being many existing apps like readitlater, etc).

Then came the idea.

I will use metadata embedded in a normal .jpg image as my file format, and organize the bookmarks as normal files in Windows Explorer! Each bookmark is represented by a .jpg image that is a screenshot of the website. The name of the file is the name of the site. The url is stored in exif metadata within the image, a standard format that can be read by many programs. Now 90% of the work is done for me - navigating, renaming, moving into folders. Syncing between machines can be done with Dropbox or Skydrive. Exporting to plain text can be done with a simple Python script. To open in a webpage, I drag the .jpg into the "bookmarkbuckets" window and the url will open in one's default browser.

1) Start with a plain text file with urls and titles on alternating lines, or a folder of .url files.
2) A short lnzscript file runs which opens each url in a browser and takes a screenshot as a .jpg image.
3) Bookmark buckets modifies the .jpg image to add the URL in exif data. It also adds the title.
Now, these .jpg files are all are needed. One can rename and categorize as needed.
To open the corresponding webpage, drag the .jpg and drop it into the "bookmarkbuckets" window.
(Bookmark buckets can also export all links back to a tab-delimited file).

It's worked well for me. I'll release to the public under a GPL license in the future.

Postscript:
It seems to me that there are (or were) 3 usages of bookmarks:
1) a shortcut to a commonly accessed page
2) a way to remember a less-commonly accessed page
3) a way to put aside a webpage in order to return to it later
(I made this list in 2007)
I note that these have changed over the past few years:
Shortcuts like the awesome bar, and Google instant have all but eliminated the need for 1.
Apps like instapaper and readitlater address 3.
I'll try to make Bookmarkbuckets effective for 2.

Waveform UI

2011-05-31T00:13:00.001-07:00

I'm having fun writing code for real-time audio effects.

If you have Firefox 4, you can play with this Waveform UI toy. Click the play button to start the audio, click and drag on the dots to change the sounds!

You can experiment with what different wave shapes sound like. In general, smoother curves have less high-pitched buzzing, because there are fewer harmonics needed to approximate that curve. I haven't found very many interesting sounds in the time domain like this, though, so you'll have to wait for further experiments to make a variety of textures.

The "cut" setting, if turned on, takes a part of the waveform and sets it to 0. (This isn't reflected in the waveform graphic.)

I made the interface using raphaeljs, which I recommend. This project is made possible by Firefox 4's cool experimental raw audio data api. Thanks to those at Mozilla.

Visualising musical appetite

2011-04-25T20:54:00.000-07:00

Last night I thought of a way to plot my music library over time. I quickly wrote a python script to make a histogram of when songs were added. Because my music is already sorted by genre, I added that to the visualization.

I call this plot "musical appetite", because that conveys both taste and quantity.

Larger render

I haven't really analyzed this, but see a few trends. Added a lot of rock in 5/2007. I think the upticks correspond with college spring and winter breaks :) Currently, nearly all growth is in 2000s and electronic. A project actually done in 30 minutes for a change.

*The music was manually sorted, as opposed to using an algorithm, but genres do overlap. My 19 categories are here combined to 11. To clarify, the category rock includes rock music from the 60s and 70s, and the decade categories "1960s" and "1970s" contain non-rock music from those times. Latin contains music from Cuba, Argentina, Brazil, and Spain. Classical here refers to composed music in general, from 1300 to the present. Other includes music from Egypt, Iraq, Bulgaria, Jamaica, some African countries, and soundtracks.

How to quickly multiply roman numerals

2011-02-11T23:57:00.000-08:00

I used to think that it would be very slow to multiply roman numerals. A few days ago, I thought of an algorithm that is actually fairly quick.

The roman symbols themselves were slowing me down, so, my first step was to come up with a different set of numerals. One might call these "potato bug" numbers. (When converting from roman numerals, also expand any shorthand so that IV is expanded to IIII and so on). Each hatch mark means a factor of 10.

and so on. This system is easier to remember and also happens to be quick to write:

Multiplication is now simple. Anything multiplied by I is the number itself. Anything multiplied by ✝ is the number times 10, which is to say: draw another hatch line on everything. When multiplying by 5, one can use the shortcuts in this table:

To generalize the table - if either or both of the inputs have hatch marks, simply add that many hatch marks on the result. Easy to remember that multiplying by ✝ is just drawing another hatch mark on everything.

One can multiply two numbers by using a "FOIL" like method by the distributive law. To multiply two numbers, take the left-most symbol of the left number, and distribute it across the symbols in the right number. The intermediary results can just be appended in one long string (because there is no place system, a ✝ is 10 wherever it is written). Then take the next symbol in the left number, and again distribute it across the symbols in the right number, and repeat. Finally, simplify the answer by grouping symbols.

There are many operations, but each is trivial and done in a split second. When later "gathering", I would underline to help me remember what I had moved into a group of 5.

So there you have it. Multiplying two digit numbers in seconds with some circles and scratches. Not as slow as you might think.

Notespad 1

2010-12-29T19:13:00.000-08:00

I've turned my dynamic compilation code towards audio. I wrote a program recently that is a "lab" for creating audio effects: you type in a few lines of code and press Go, and the code is compiled and run. These processing snippets can be saved, along with parameter settings. I jokingly call it Windows Notespad.

With this tool I can quickly prototype audio effects. As a source I will use Cathy Berberian's reading from Joyce's Ulysses. (This is an excerpt from Luciano Berio's piece Thema, Omaggio a Joyce).

Some interesting changes can be made in the frequency domain. I divide the audio into many overlapping pieces. If I take the dft of each piece, change the phases every 256 samples, and ifft back, this imparts a high tone to the sound (frequency = 44100hz / 256 = 689hz), turning the speaking into singing. If I make each piece 0.1 seconds, ramp the pieces for a smooth transition, and set the phases to random values, I can 'smear' the sound, keeping the frequency content within each piece but losing the envelopes. This resembles adding a lot of reverb.

Hear:

The original, for comparison:

I wrote a script to plot amplitude (average signal power) over time. Plotted on a log scale, it looks like this:

One thought was to turn this curve into pitch. What if one played a sine wave corresponding to these pitches? I experimented with code until I found an effect like a bird's song.

Another non-linear transformation is to change the pitch based on power. Imagine a poor vocalist who goes sharp on loud notes and sings flat on soft notes. What if the whole band played this way? The effect is too comical to include.

We can find the loudness at a certain point in the audio clip. The idea struck me: what does it sound like if all of the quiet parts are made loud, and the loud parts made quiet? If find the effect to be rather terrifying:

There is much left to explore.

drawdraw

2010-11-06T18:53:00.000-07:00

drawdraw is a web app for recursive drawing. Try it!

Instructions: Click the buttons to make things. Drag the green dots to move things. Experiment until it looks cool. Send links.

Now that you have spent time playing with the program:
The light-blue arrow in the background represents the initial scale and rotation. At every step, the orange arrows are replaced with a scaled and rotated copy of the figure. If an orange arrow is longer than the light-blue arrow, the figure "explodes" because the size increases with every step.

In the end, if enough steps are done (the pencil+ button adds more steps), look at the result - the location where each orange arrow will contain the entire figure (picture a tree, where each branch can have the form of the entire tree). It is self-similar, a property held by fractals. Because this program represents a set of affine mappings, it can be used to draw all of the traditional IFS fractals in a new manner.

Have fun!

(I wonder how one would make a non-linear version...)

plotmydata

2010-10-23T13:51:00.000-07:00

Need to plot some data quickly? Try plotmydata.blogspot.com.

Your data is plotted in real time as you type, or you can copy/paste in your data in csv format.

This is for the times when you don't want to wait for Matlab to open, and it's not worth it to write a python matplotlib script/use a command line tool.

What features do you want - uploading text files? scatter plots? zooming? comparing multiple trends? plotting an arbitrary function? anything else? I'm all ears.

Just one of those projects. It makes use of Stanford's protovis library.

pixels

2010-09-03T22:44:00.000-07:00

I've taken a break from writing music this summer and have done this instead.

Thread Unsafety

2010-08-18T18:10:00.000-07:00

#!/usr/bin/env python
import time,itertools
from threading import Thread

class FizzBuzz():
  g_place = ''
  def th(self, t, tminc, fn):
    start = time.clock()
    while True:
      t +=tminc
      while time.clock()<start+t: time.sleep(0.01)
      self.g_place = fn(self.g_place)
    
  def go(self, counter, printer):
    thds = ((0.7, 1.0, lambda c: printer(c)), 
      (0.0, 1.0, lambda c: counter.next()),
      (0.1, 3.0, lambda c: 'Fizz'), 
      (0.2, 5.0, lambda c: 'FizzBuzz' if c=='Fizz' else 'Buzz'))
    for thd in thds: Thread(target=self.th, args=thd).start()

def _print(s): print s
FizzBuzz().go(itertools.count(1), _print)

As far as I know, this is a unique way to code FizzBuzz. It's also a pretty bad way, for a variety of reasons. But at least it's multithreaded!

Physics into audio

2010-08-14T00:10:00.000-07:00

I've been toying with the idea of using physics simulations to generate audio.

First, imagine a audio in a circular loop, as on a record player. As the needle moves clockwise, the music plays. If the needle moves counter-clockwise, the music is played backwards. The faster the needle moves, the faster (and higher pitched) the sound.

Now, model the chaotic motion of a double pendulum, and use that as the needle that is driving the music:

It can also be interesting to use the data directly. Take a physics model of a double pendulum, and record the height (y) of the longer leg over time. Then, interpret that data as raw audio samples and play it!

Double pendulum as raw audio by jamonben

I inadvertently created a mashup while working on a related project, but it's not very good.

LnzScript 0.4

2010-08-02T22:04:00.000-07:00

The LnzScript 0.4 release is here! This scripting tool can automate repetitve tasks in Windows, work with files and folders, and easily perform text manipulation.

The editor makes it easy to write quick one-off scripts. Standard output appears in a pane to the right. Let's say you have some text that you want shuffled randomly. If one were to write a Python script, you'd have to save the text in a temporary file, or load some library to access the Windows clipboard. With LnzScript, the clipboard is directly accessible without importing anything. One could just write Clipboard.set(Math.shuffleArray(Clipboard.get().split('\r\n'))) Furthermore, the LnzScript Editor can run a script before it has even been saved to a file, a unique feature, so you can run a script immediately.

LnzScript 0.4 includes more methods for working with files. File.dirListFiles(@'c:\myfolder', '*.txt','size') returns all of the text files in the directory, sorted by size. File.copyMany can copy full directories. File.createShortcut and File.getShortcutTarget can work with shortcuts. The Rename.renameFn will call a function you provide to rename files. To rename .jpeg to .jpg, say, all you need to do is:

File.cd(@'c:\myfolder');
Rename.rename('.jpeg','.jpg');

Rename.renamePreview can be used to see the results before renaming anything.

And, it's still good at automating tasks. I used it to access Webmail (for which there was not a 'remember me' option); much faster than typing in the fields every time. An old demo of LnzScript opening Firefox tabs is here.

The installer associates script files so that you can run them by double-clicking. Just by using argv in a script, you can now drag and drop a file into the script and it will run with that argument in argv[1], a 'droplet.' Lately I've been using Clavier+ to assign scripts to hotkeys. Other programs such as Launchy could also be used.

Why JavaScript? I find it to be much cleaner than Basic-derived semi-languages. Lambdas and the good parts can be very useful. I've added @'string' literals to the language, that can contain single backslashes, so that one can type @'c:\foo' instead of 'c:\\foo'. There are other additions like include(), alert(), print(), and argv.

Parsing .url shortcuts in a directory and printing out URLs:

File.cd(@'C:\folder');
var arFiles = File.dirListFiles('.', '*.url')
for(var i=0; i<arFiles.length;i++)
{
  var pageName = arFiles[i].slice(0,-4)
  var url = File.readFile(arFiles[i]).split('URL=')[1].split('\n')[0]
  print(pageName)
  print(url + '\n')  
}

An example using JavaScript's closures to rename files in the pattern 00, 01, 02, and so on, by last modification time:

include('<std>')
File.cd(@'C:\folder')
var i=0;
function renameNumbered(s)
{
  i++;
  return (i<10)?'0'+i+s : i+s;
}
//first, preview to see consequences
Rename.renameFnPreview(renameNumbered, 'time')
//then,
//Rename.renameFn(renameNumbered, 'time')

Audiovisual

2010-07-14T21:56:00.000-07:00

I few months ago I was struck with an idea. What would it look like if traditional audio effects were applied to videos?

I could treat every pixel as a separate signal in time, with its brightness being the value. These become sequences of values, just like streams of audio data. I could put these signals through various audio filters, like high-pass, low-pass, and so on. (I solely apply effects in time, not space.)

I wrote code in C that worked on individual frame images at the pixel level in order to have complete control.

Applying a low pass filter to all pixels created a motion-blur like effect, because it was essentially blurring together consecutive frames. A high pass filter looked more interesting - the video became all dark except for the areas with the fastest motion. Things really started to get interesting, though, when I used other audio effects. Watch this:

A flange effect can be created with is the sum of two signals: one is the input signal, unchanged, and the other is the input signal alternating between being played slightly faster, and slightly slower. Because of the alternation, they stay in sync, but the effect is heard as a moving, shimmering sound. (Used in guitars in psychedelic rock).

I applied an exaggerated version of this effect. I combine the video signal with an altered version of itself that speeds up and slows down, just like a flange effect. This means that sometimes the altered signal is a ghostly signal sometimes ahead in the future, and sometimes lagging behind.

The effect with rainbow colors is related to a high pass filter - the areas that are changing the most are the ones that are allowed to overflow into vivid colors.

In audio, there are methods of looping a non-periodic sound. One way is to play many copies of the sound offset in time, but giving each a envelope, so that each piece on its own fades in and out, and isn't very noticeable. I used this in the last effect of the video, creating a loop.

Launchorz scripts

2010-07-06T19:13:00.000-07:00

My Launchorz project makes it easy to automate repetitive tasks in Windows. Here are some of the scripts I've found to be the most useful. (Note that they are intended for Windows 7 and might not be compatible with something earlier.)

Open command-line to the current Explorer directory

include('getExplorerDirectory.js');
Window.activate( {'class':'CabinetWClass'});
// activate the most-recently-used Explorer window.
Time.sleep(100);
var strDir = getCurrentExplorerDirectory();
if (strDir)
  Process.openFile('cmd.exe', strDir);

You can download getExplorerDirectory.js.

Creating an index of all files in a directory

This script creates a text file index of all files in a directory, including subdirectories. The output is formatted nicely by indentation level. It uses the path of the currently open Explorer window and creates tree_files.txt.

include('getExplorerDirectory.js');

Window.activate( {'class':'CabinetWClass'})
Time.sleep(100);
var strDir = getCurrentExplorerDirectory();
if (strDir)
  Process.open('cmd.exe /c tree /f /a > tree_files.txt', strDir);

Expand repeated code

When working on a quick project, or writing in a language like Verilog, sometimes the same line of code is repeated a few times, with a different index. The following script takes a code fragment like
a[#] = b[#] & c[#];
and expands it to
a[0] = b[0] & c[0];
a[1] = b[1] & c[1];
a[2] = b[2] & c[2];
...
(This isn't a useful example but it depicts what the script does). All it does is replace the '#' character with a number.

include('<std>');
var sClipboard = Clipboard.getText();
if (sClipboard  && sClipboard.contains('#'))
{  
  var sRep = Dialog.input('Replace', 'How many repetitions? n=0 to ?', '3');
  if (isNumber(sRep))
  {    
    var sResult = '';
    for (var i=0; i<sRep; i++)
      sResult += sClipboard.replace(/#/g, i) + '\r\n';
    Clipboard.setText(sResult);
  }
}

Sort lines in the clipboard

var strClipboard = Clipboard.getText();
if (strClipboard) 
{
  var arr = strClipboard.split('\r\n');
  arr.sort();
  var strResult = arr.join('\r\n');
  Clipboard.setText(strResult);
}

(You could also normalize the line endings with strClipboard.replace(/\r\n/g, '\n') and split on \n).

Displaying an ANSI table

//opens an ascii table in notepad.
var s ='';
for (var i=32; i<128; i++)
{
  var si = (i<100)?' '+i : i.toString();
  s+= si + '\t' + String.fromCharCode(i);
  s+= '\r\n';
}
File.writeFile( File.getPathTemp()+'\\tmpascii.txt', s);
Process.open('notepad.exe '+File.getPathTemp()+'\\tmpascii.txt');

Showing a simple reference of ansi characters.

I also have a clipboard replacement script that gives you 26 different clipboards, each recalled by a letter. However, there exist many other clipboard-handling tools.

To learn more about Launchorz, you can watch some screencasts here. (It is similar to AutoIt, but has a full JavaScript language and namespaces).

Chaotic Maps!

2010-06-02T23:41:00.000-07:00

This is the first release of "fastmapmap", a program I wrote that plots 2D chaotic maps. A discrete chaotic map will take the point (x,y) to a new (x_, y_) based on a function. For example, the Henon map takes the point (x,y) to (y+1-a*x*x, b*x), where a and b are constants. One can draw a "portrait" of a map by choosing an (x0, y0) and repeatedly evaluating the function, shading in each point that is landed on. Depending on the values of a and b, sometimes the point moves off to become very large, or sometimes the point alternates jumping between two or more values. Other times, the points shade in a region in a complicated way, never repeating, which is a chaotic orbit.

The program fastmapmap can draw these portraits in real time. (I put some effort into optimization). The parameters a and b can be quickly changed with the arrow keys. The plot can be easily navigated; hold alt and drag the mouse to zoom in on a region.

The program is called fastmapmap because an additional plot can be drawn that is a "map" of the behavior of the map. The x axis represents the constant a and the y axis is b. In this plot, black areas are periodic, red areas escape to infinity, and colored areas are chaotic. So, the plot can depict which parameter values may be interesting to observe.
It's cross-platform, tested in Windows and Ubuntu. Try it! Download Windows | Source (GPL)

A short tutorial:

Open fastmap.exe
Tap the right arrow a bit to change the value of a.
Press Ctrl-s, type 'test', and press Enter to save as test.cfg
Ctrl-click on the shape to zoom in, Shift-click to zoom out
Press Ctrl-o, type 'test' and press Enter to open our test.cfg
Press Alt-b and watch the shapes move
Press Alt-b again to stop movement
Click the cross-hairs icon to show the diagram. Click in the diagram.
Click the "..." icon to read what else can be done.

The program can easily create animations. Hit Alt-B and watch the shapes start to move. Use Ctrl-F1 through Ctrl-F9 to set a keyframe. Refer to readme.txt for all of the other features.

I came up with other drawing modes. In the following, x and y represent x0 and y0, and the color is chosen according to the value after 20 iterations.

Assigning colors based on quadrant:

I invented this drawing method originally as way of depicting the action of the Henon map.

Remember to download: Windows | Source

SDL Text and Dialogs

2010-06-02T13:32:00.001-07:00

For one of my recent projects, I wanted dialogs in an sdl program. This small library draws simple "dialogs" to ask the user for text or a number.

Usage:

// where SDL_Surface* pSurface is the screen surface.
char * s; 
s= Dialog_GetText("Enter your name:", "Fred", pSurface);
Dialog_Messagef(pSurface, "Welcome, %s", s);
free(s);

double val = 1.5;
Dialog_GetDouble("Enter a value", pSurface, &val);
int n = 1;
Dialog_GetInt("Choose a number.", pSurface, &n);
if (Dialog_GetBool("Double the number?", pSurface))
  n*=2;
Dialog_Message("Goodbye", pSurface);
freeFonts();

To draw text, I used the code at this page. (I added the ability to have newlines and tabs). It supports lower ascii chars, and code could be improved, but currently suits my purposes. There's also SFont and others.

Source (includes a bitmap font).

SSE instructions

2010-04-25T14:22:00.000-07:00

For the past few weeks I have been experimenting with Streaming SIMD Extension instructions. It takes a while to write at this lower level, but I've been able to get my code to run 3 times faster!

Most processors since about 1999 contain eight 128 bit registers that can be used to do multiple computations in one instruction. 128 bits can hold 4 32-bit floating point numbers, and so there could be a theoretical 4x improvement in speed, as long as the same operation is done to each. For example, if you have two arrays a and b , and want to sum them, instead of:

float a[4]; float b[4]; float c[4];
//...
c[0] = a[0]+b[0];
c[1] = a[1]+b[1];
c[2] = a[3]+b[2];
c[3] = a[3]+b[3];

, this can be expressed as:

__m128 a, b, c;
// ...
c = _mm_add_ps (a, b);

The _mm_add_ps "instrinsic" becomes 1 instruction on the cpu (addps) instead of 4. Similar code can be written with 32-bit integers, and a few other data types. (Technology like CUDA is faster, though). In case you are interested, here is an example of optimizing with SSE instructions.

The following code will draw a chaotic map (c1 and c2 are parameters). For this particular map, we know that initial points or "seeds" close to (0.0,0.0) are good starting points. Let's say, for fun, that we want this to run as fast as possible.

const int nseeds=4;
float xseeds[nseeds] = {0.0f, 0.0f, 0.0f, 0.0f};
float yseeds[nseeds] = {0.000001f, 0.000002f,-0.0000011f,-0.0000011f};
float x, y, x_, y_;
for (int seed=0; seed<nseeds; seed++)
{
  x=xseeds[seed]; y=yseeds[seed];
  // ... settling code ...
  
  for (int i=0; i<PixelsToDrawPerSeed; i++)
  {
    x_ = c1*x - y*y; 
    y_ = c2*y + x*y;
    x=x_;
    y=y_;
    if (ISTOOBIG(x)||ISTOOBIG(y)) break; 
    //if escaping to infinity, there won't be more points drawn, so quit early.
    //quitting early is important, far slower without this.

    //scale to pixel coordinates, and plot point if it is within bounds. X1 is greatest x, and so on.
    int px = (int)(SIZE * ((x - X0) / (X1 - X0)));
    int py = (int)(SIZE * ((y - Y0) / (Y1 - Y0)));
    if (py >= 0 && py < SIZE && px>=0 && px<SIZE)
      arr[px+py*SIZE] = 1; //plot point at px, py.
  }
}

Runtime for 1,310,720 different parameters is Test 1: 14,747ms, Test 2: 25,026ms. First, I added threading to to take advantage of the two cpu cores. I made sure to balance the work so that each thread is kept busy. This improved time to Test 1:7,452ms Test 2:12,617ms.

At first glance, it's not obvious how this could be optimized. I was a bit concerned about the (int) casts becoming a slow _ftol call, but looking at the generated assembly showed that this wasn't the case. (Read here,here for why casts can be slow, although with modern compilers and instruction sets this doesn't seem to be an issue).

In visual studio, I noticed a setting for Streaming SIMD Extensions 2 (/arch:SSE2). With this enabled, the compiler was able to vectorize some of the code (I verified in the asm that it was using the xmm registers), which resulted in an ok speed increase. Test 1:5,981ms Test 2:10,987ms

Can I do better?

Here is my first attempt at a vectorized version, moving all 4 points at once.

__m128 x128 = _mm_setr_ps( 0.0f, 0.0f, 0.0f, 0.0f);
__m128 y128 = _mm_setr_ps( 0.000001f, 0.000002f,-0.0000011f,-0.0000011f);
__m128 mConst_a = _mm_set1_ps(c1); //sets all 4 fields to c1
__m128 mConst_b = _mm_set1_ps(c2);
__m128 nextx128, tempx, tempy;

__m128i const_size = _mm_set1_epi32(SIZE), const_zero = _mm_set1_epi32(0);
// ... settling code ...
for (int i=0; i<PixelsToDrawPerSeed; i++)
{
  nextx128 = _mm_sub_ps(_mm_mul_ps(mConst_a, x128), _mm_mul_ps(y128,y128));
  y128 = _mm_mul_ps(y128, _mm_add_ps(x128, mConst_b)); 
  x128 = nextx128;

  if (ISTOOBIG(x128.m128_f32[0]) ||ISTOOBIG(x128.m128_f32[1]) ||
    ISTOOBIG(x128.m128_f32[2]) ||ISTOOBIG(x128.m128_f32[3]) ||
    ISTOOBIG(y128.m128_f32[0]) ||ISTOOBIG(y128.m128_f32[1]) ||
    ISTOOBIG(y128.m128_f32[2]) ||ISTOOBIG(y128.m128_f32[3] ))
  {
    break;
  } //assume that if one is too big, all four will be too big, nearly always valid for this map

  //scale to pixel coordinates. assume that pixels are square, that X1-X0==Y1-Y0.
  //the following computes px = (int)(SIZE * ((x - X0) / (X1 - X0)));
  __m128 mConst_scale = _mm_set1_ps(SIZE / (X1 - X0));
  tempx = _mm_sub_ps(x128, _mm_set1_ps(X0));
  tempx = _mm_mul_ps(tempx, mConst_scale); 
  tempy = _mm_sub_ps(y128, _mm_set1_ps(Y0));
  tempy = _mm_mul_ps(tempy, mConst_scale); 
  __m128i xPt = _mm_cvttps_epi32(tempx); //cast to int32
  __m128i yPt = _mm_cvttps_epi32(tempy); 
  __m128i xInBounds =  _mm_and_si128(_mm_cmpgt_epi32(xPt, const_zero), _mm_cmplt_epi32(xPt, const_size));
  __m128i yInBounds =  _mm_and_si128(_mm_cmpgt_epi32(yPt, const_zero), _mm_cmplt_epi32(yPt, const_size));
  __m128i inBounds = _mm_and_si128(xInBounds, yInBounds);
  
  if (inBounds.m128i_i32[3] != 0)
    arr[xPt.m128i_i32[3] +yPt.m128i_i32[3]*SIZE] = 1; //plot point
  if (inBounds.m128i_i32[2] != 0)
    arr[xPt.m128i_i32[2] +yPt.m128i_i32[2]*SIZE] = 1; //plot point
  if (inBounds.m128i_i32[1] != 0)
    arr[xPt.m128i_i32[1] +yPt.m128i_i32[1]*SIZE] = 1; //plot point
  if (inBounds.m128i_i32[0] != 0)
    arr[xPt.m128i_i32[0] +yPt.m128i_i32[0]*SIZE] = 1; //plot point
}

It is convinient that conditions can be expressed in SSE with the and instruction and comparison instruction. If a comparison is true, the field is filled with 0xffffffff, and if false, 0x00000000. This version was faster. Test 1: 4,650ms Test 2: 7,293ms

It was clear from the generated assembly that the ISTOOBIG(x128.m128_f32[0]) ||ISTOOBIG(x128.m128_f32[1] was inefficient, as it had to move data out of the xmm registers before comparing. I then learned about _mm_movemask_ps, which does exactly what I want. It condenses the 128 bits into 4 bits of an integer in one step, much faster than moving out data four times, and so I could write

//instead of ISTOOBIG(x128.m128_f32[0])||ISTOOBIG(x128.m128_f32[1]) and so on
__m128 estimateMag = _mm_add_ps(x128,y128); //estimate magnitude as (x+y)(x+y)
estimateMag = _mm_mul_ps(estimateMag,estimateMag);
__m128 isTooBig = _mm_cmpgt_ps(estimateMag, constThreshold);
if (_mm_movemask_ps(isTooBig) != 0) //if any of the four fields are true
  return 0;

This increased speed dramatically! The score is now Test 1: 1,956ms, Test 2: 3,323ms! I later saw on this site assembly for a quick absolute value hack. I used the idea and rewrote as

__m128 estimateMag = _mm_add_ps(x128,y128); //estimate magnitude as abs(x+y)
estimateMag = _mm_andnot_ps(_mm_set1_ps(-0.0f), estimateMag); //credit: Concatenative language wiki
__m128 isTooBig = _mm_cmpgt_ps(estimateMag, constToobig);
if (_mm_movemask_ps(isTooBig) != 0) //if any of the four fields are true
  return 0;

A further optimization was to vectorize finding the array pixel location. Instead of "if (inBounds.m128i_i32[3] != 0)...", I could write:

//Make size a power of 2 so multiplication is a shift left. Example: SIZE=128,LOG2SIZE=7
__m128i pixel = _mm_add_epi32(xPt, _mm_slli_epi32(yPt, LOG2SIZE)); //pixel=xPt+yPt*size 
pixel = _mm_and_si128(inBounds, pixel); //draw out-of-bounds pixels at 0,0
arr[pixel.m128i_i32[3]] = 1; //plot point
arr[pixel.m128i_i32[2]] = 1; //plot point
arr[pixel.m128i_i32[1]] = 1; //plot point
arr[pixel.m128i_i32[0]] = 1; //plot point

Note that I've eliminated some conditionals. The trick is to mask out the point if inBounds is false with the line "pixel = _mm_and_si128(inBounds, pixel);". False is represented by 0x00000000, and so if inBounds is false, pixel is set to 0. All out-of-bounds pixels are drawn onto (0,0), but this pixel can be cleared later. Speed is improved to Test 1: 1,726ms, Test 2: 2,991ms.

If it were likely that a pixel would be out-of-bounds, I could change the order and check inbounds much earlier, before casting to int, and do things like checking if x is in bounds before calculating y. Because this case not occur often, it is not worth attention.

I notice some redundancy in "int py = (int)(SIZE * ((y - Y0) / (Y1 - Y0)))" and "pixel=x+y*size." In both, y is multiplied by a constant. I could eliminate a multiply with something like:

int py_times_size = (int)(SIZE*SIZE* ((y - Y0) / (Y1 - Y0)))
if py_times_size>0 and py_times_size<SIZE*SIZE and x>0...
pixel=x+py_times_size.

This didn't work in sse vectors because of overflow with _mm_cvttps_epi32.

My final step is the least elegant: loop unrolling. Repeating the loop body 4 times gave the fastest results. (Faster because less overhead and maybe better scheduling, there is a trade off because of cache misses as size increases). There are additional savings because I only need one "isTooBig test" per every four iterations, and so I deleted all but one of the tests from the loop. It doesn't matter if the point is too big for a few iterations as long as we realize it within a few iterations. This final step also made a significant difference.

Our final times are Test 1: 1,346ms, Test 2: 2,285ms. This amount of optimization, by about a factor of 4, can be the difference in a real-time program. The code in this example, by the way, makes it possible to quickly draw this rather striking figure:

Bifurcation

2010-03-08T15:18:00.000-08:00

I wrote a program to draw bifurcation diagrams of any 1-dimensional map.

Recently, I studied 1-dimensional maps in my nonlinear dynamics course. I recommend reading about this topic: it is fascinating that an expression as simple as p_next = r*p*(1-p) can lead to what is known as "chaos." r is a constant, p is a number between 0 and 1, and the expression is repeatedly evaluated. The resulting sequence of p can either settle to a fixed number, periodically cycle between values, or continue aperiodically and seemingly in a random fashion. A bifurcation diagram concisely depicts the behavior as the parameter r changes. Read more about the logistic map on Wikipedia or elsewhere.

I used Matlab for most numerical work pertaining to the course. In my spare time, though, I wrote this program to experiment with different maps and parameters. Also, because the program runs so much more quickly, I could create better images without waiting. (This program builds upon my earlier project that dynamically compiles code, and so it runs efficiently.)

Download (Unzip and run CsBifurcation.exe).
Source (GPLv3 license)

To use the program, type in an expression, and click Go. By default, the famous logistic map is shown. Use the mouse to zoom in. By holding the Alt key and dragging, you can zoom in on a non-square rectangle of the plot. Refer to the readme.txt file for more information. I encourage you to run this program and explore the intricate details of the logistic map, and to invent your own 1D maps. The program can also create animations by slowly changing one of the parameters over time. I will post some of the animations I've made at a later date.

As I wrote new expressions and drew bifurcation diagrams, I began to search for interesting shapes and details. I began to compose images based on appearance rather than mathematical properties. A selection of this work:

An Excessively Fast Graphing Calculator

2010-02-09T11:13:00.000-08:00

Lately I've been exploring the code-generation features of the .NET framework. It's cool to be able to compile and run new code at runtime. The CSharpCodeProvider and System.CodeDom.Compiler classes provide this ability.

Evaluating code at runtime is especially useful when accepting user scripts, or evaluating a new mathematical expression. In Python, one can use eval() or exec to run code, but in C# the process is more complicated. So, I wrote a wrapping class with a convenient interface, that can be reused in other projects.

For example, public double simpleMathEval(string strExp, out string strErr) can easily evaluate an expression: double ret = simpleMathEval("1+3+Math.sin(4.6)", out strErr); The more advanced method mathEval accepts any amount of code and inner functions.

As a proof of concept, I wrote a graphing calculator. It's really fast - compiling your expression. When you click Plot, a new program is generated that is essentially a loop containing your expression. (Compilation or runtime errors are caught and relayed back to you). On the graph, zoom in easily by clicking and dragging to draw a rectangle.

(Note that I try to be intelligent when drawing asymptotes, making this plot of cosecant look cleaner than if it'd been plotted in Matlab). I based the code on the efforts of Mike Gold's "CodeDom Calculator", but made a new interface and extended it to allow arrays. As the title of this blog suggests, though, I haven't polished or thoroughly tested it.

A more advanced example - you can put all sorts of code in here.

To see how to use CodedomEvaluator, CodedomTest.cs contains some examples. CodedomEvaluator Usage:

double simpleMathEval(string strExp, out string strErr)
-evaluates a string, not a full statement. example: "3.0*5.1"returns 15.3.
double simpleMathEval(string strExp, string strVarname, double varValue, out string strErr)
-same as above, but provide a variable. 
example: strVarname="x", varValue=3, "x*x" returns 9.0.
double mathEval(string strExp, Dictionary<string, double> vars, out string strErr)
-evaluates a string that is a full statement. must assign to "ans". 
the vars dictionary can be used to provide variables.
example: vars["x"] = 3.0, "ans=x+4;" returns 7.0.
double[] mathEvalArray(string strExp, Dictionary<string, double> vars, int arrayLen, out string strErr)
-like above, but will return an array of values. The array arrAns[] will be created of length arrayLen.
example: arrayLen=40, "for(int i=0;i<40;i++) arrAns[i]=i*i;"
Because the inner loop is compiled, 
this is a fast way to evaluate an expression many times.

Windows binary
C# src, GPL v3.

An idea for music transcription.

2009-11-26T21:57:00.000-08:00

Many musicians spend time transcribing music, using computer software such as Sibelius or Finale to enter notes into sheet music. This process, though, could use improvement, particularly when a midi keyboard is not available. (In some programs the computer keyboard mapping is not intuitive; in Finale 2006, one enters notes by typing their letter names. The "g" key produces a g note and so on - but on a qwerty layout, this doesn't work well, because of the non-consecutive placement of a,b, and c. Also, I have yet to see a good way to select note duration.) Both Finale and Sibelius have recently released new transcription features, such as Sibelius' keyboard window introduced in May 2009. Here I will introduce one of my ideas for faster music transcription.

Instead of following an arbitrary metronome when recording, my program lets the performer tap the pulse themselves. This lets the performer play more naturally, and also to slow down for parts of the music that are more complex. I recently finished a proof-of-concept of this system that needs only a standard computer keyboard. The keys are played like a piano, and the Tab key is tapped for every quarter note. It works well; I've already used it to transcribe some of a Bach cantata.

Some screenshots of the prototype, called "Trilling":

A short fragment, saved to MusicXML and imported by Finale:

The same fragment, saved to LilyPond:

Even if you don't have Finale, Sibelius, or LilyPond installed, you can see a rough preview of the music, drawn by my little "scoreview" program:

I plan to take this project forward, adding more features, and creating a truly useful tool for music transcription.

In order to export to MusicXml and LilyPond, I use code from an open source project called Mingus. I'm grateful for that project, which turned out to be very similar to what I needed. I added the capability of tied notes and changed some of the ways it writes musicxml files.

Download source, requires Python 2.5, released under GPLv3.
At the moment, it only runs on Windows because I am using the winsound module to play .wav files in real-time. (I'm not using midi output anymore because, if one doesn't have hardware midi, there is a noticeable delay during playback.)

Doppler Effect Simulation

2009-11-22T21:29:00.001-08:00

Here's a hacked-together-in-one-night project just like the ones from the old days.

ex1.wav

This is a Doppler effect simulation, in order to create the sound of particles whizzing past you, in stereo. You, the "observer", are represented by the L and R rectangles. The green numbers represent points along the path of that the particle travels. One specifies the path by moving the position of the numbers, using the mouse. If your points are spread apart, the particle travels faster, and if the points are close, the particle moves slower.

It's fun to play with. I recommend downloading and trying it. By clicking the checkbox, a second particle can be added.

ex2.wav

ex3.wav

ex4.wav

The physics are only approximate, because this is an audio project and not a physics project. Each pixel corresponds to 2 meters. The distance between L and R "observers" is deliberately exaggerated to get a better stereo effect. The volume is scaled by 1/r instead of 1/(r^2), in order to hear the particle more easily when it is far away. This is something to explore further.

I was able to write the code quickly. The expression (V/(V+vS)) gives a frequency shift, so if this value is 1.5, the perceieved pitch is 1.5 times higher. It turns out that this frequency shift is very well suited to code. First, I generate many seconds of source audio, say a sine wave at a fixed frequency. Then, I walk through this source audio at the "frequency shift" rate, interpolating between values when needed. So if the "frequency shift" came to 1.3, I would take the 0th,1.3th,2.6th,3.9th, samples from the source audio as the output audio, which results in output audio with a 1.3 times higher pitch. The whole project simplified to this:

fPositionInSourceAudio=0.0;
V = 340.0; //speed of sound
//for each timestep:
//move x and y
//find distance between particle and observer
distance = Math.Sqrt((x-xMe)*(x-xMe) + (y-yMe)*(y-yMe));
vS = (distance - prevdistance) / dt;
freqShift = (V / (V + vS));

intensity = scale * (1 / distance);
for (int i = 0; i < dt*sampleRate; i++)
{
outputAudio[index+i] = intensity * interpolatedValue(sourceAudio, fPositionInSourceAudio); 
fPositionInSourceAudio += freqShift;
}

doppler_fx

Download (Windows), unzip and run Doppler.exe. No setup needed.

Source, released under GPLv3.

Computer keyboard as piano keyboard

2009-11-16T13:20:00.000-08:00

A continuation of a program I wrote a few years back, this little app lets you use your computer keyboard as a piano keyboard:

It can be useful for recording fragments of melodies or songs. The results are saved as a standard .mid file. Also, because it supports easy multi-tracking, it can be fun to make a little song by combining a bass part, harmony, and melody with different instruments for each voice.

(Midisketch sends out real time midi events. So, if a midi loopback driver like Maple or LoopBe1 is used, it can act like a midi input device as well. In fact, it might be interesting to have Midisketch install keyboard hooks like Ctrl-alt-a, Ctrl-alt-b, and so on, that would play the corresponding notes even when the program is minimized. Then it could be used just like a midi keyboard, and recognized as such by other software).

Anyways, here is a short video showing the keyboard:

Midisketch demo from bngjbng on Vimeo.

Three or more note polyphony is supported, constrained only by limitations of most keyboards. The "C# MIDI Toolkit" by Leslie Sanford is used to send midi data to the Windows api.

Download, win32.
(Unzip the file and run Midisketch.exe. See also readme.txt. Requires .NET 2).
Source.
Released under Gplv3.

Audio: noise

2009-11-11T18:28:00.000-08:00

I have been continuing some digital audio experiments.

I find red noise to sound calmer and more natural than white noise. (Red noise can be produced by integrating white noise). The way I produce red noise is to start with a single value, add a small random (positive or negative) sample to it, and then continue. In white noise, the samples are unconnected leaps, but for red noise, the samples do not change as drastically.Let's say one takes a small chunk of red noise, 220 samples long. If one plays this chunk repeatedly, a 200hz tone is heard. The tone is colored by the frequencies present in the initial chunk of noise.

Now let's create 15 different chunks of red noise, each of length 220. If we play one of the chunks ten times, then the next ten times, then the next ten times, and so on, eventually repeating,the result is a nice "warble" at 200hz. The upper frequencies present change abruptly about 20 times a second, causing a robotic sound. This is a fun sound that can be used for various purposes.

out_r.wav

However, what if our goal is to create a more natural sound? As mentioned before, a problem is that the frequency content changes abruptly. We want to create more subtle changes, while still having the presence of buzzing red noise.

The solution I came up with was inspired by how the red noise was created in the first place. I still begin with a chunk of red noise. After playing it ten times, instead of switching to an entirely different chunk, I instead slightly alter the chunk: by adding small random (positive or negative) values to each of the 220 samples. In this way, the frequency content does not change suddenly, and yet it changes in an unpredictable and subtle way. I find the resulting tone to still be harsh and noise-like, but surprisingly natural and musical. In the past it has only been in the frequency domain that I've been able to produce natural sounds.

Two examples of this "softened noise":

softened.wav

pulsedrop.wav

The second is seeded initially with a sine wave, and higher frequencies emerge over time.

I've been using my C audio library, "bcaudio", for these experiments. Writing psuedo-object-oriented C isn't that bad. It's fun to write code that will run very quickly.

bcaudio.tgz

Simple image output

2009-05-10T01:53:00.000-07:00

Sometimes, it can be nice to have a dead-simple format for bitmap images. If I'm writing some low level code (say, in C) dealing with graphics, at times I will want a quick way to quickly output an image file. Let's say that I'm too lazy to bring in a graphics library that can write actual .pngs . The .bmp format, while simple, is a bit more complicated than a list of rgb values, because of alignment.

I wrote a little program that converts ".simple" images (which are a list of R,G,B bytes) into 24 bit .bmp files. So, your program simply writes a tiny header and three bytes per pixel, and simpletobmp.exe turns this into a .bmp.

This works well from Python, too, when the PIL isn't around.

Here is an example of how to draw a ".simple" image:

FILE * fout;
fout = fopen("test.simple","wb");
fputc('S', fout);
fputc('2', fout);
fputc('4', fout);
int x,y,width,height;
width = 512; height = 256;
fwrite(&width,sizeof(int), 1, fout); 
fwrite(&height,sizeof(int), 1, fout); 

for (y=0; y<height; y++)
{
  for (x=0; x<width; x++)
  {
    fputc( y%256 , fout); //Red
    fputc( x%256 , fout); //Green
    fputc( 0 , fout);          //Blue
  }
}
fclose(fout);

Or, in Python,


import array
fout = open('pyout.simple', 'wb')

chars = array.array('c') #char
chars.append('S')
chars.append('2')
chars.append('4')
chars.tofile(fout)

WIDTH=512; HEIGHT=256
ints = array.array('l') #signed long
ints.append(WIDTH)
ints.append(HEIGHT)
ints.tofile(fout)

bytes = array.array('B') #unsigned char
for y in range(HEIGHT):
 for x in range(WIDTH):
  bytes.append(y%256)
  bytes.append(x%256)
  bytes.append(0)

bytes.tofile(fout)
fout.close()

(This one draws a gradient in red and green. Change the fputc lines in the inner loop to draw the image you want. A common usage is to set up a 2d array of pixels, draw the picture into that array, and then output everything to a file).

Now, one can run

simpletobmp.exe o test.simple test.bmp

to get the image.

This is very similar to how in Linux, one can write a .ppm file, which is, literally, a brief header and list of rgb values. The .ppm format even accepts pixel information in human-readable ascii digits! Sounds ridiculous, but this type of thing can be useful.

Download:
Windows binary
Source LGPL license.

Simpletobmp uses the LGPL bmp_io library by John Burkardt.

Bit packing preprocessor

2009-05-10T00:12:00.000-07:00

When working at lower-levels, sometimes it pays to conserve bits. Binary formats sometimes use all of the bits they are given - when I was working with MIDI, I came across this a lot. (If you have a full int, you might as well use all 32 of those guys.)

On a more practical note, 16bit color is often 5bits red, 6bits green, and 5bits blue. A color is stored as a 16 bit integer in the format rrrrrggggggbbbbb, where each letter represents a bit. It isn't difficult to write code to extract these bit fields, but to make it faster and more readable, I wrote some Python to write the C for me. The Python script takes a string like "00rrr000" and outputs C code with the appropriate shifts and masks.

Bit tools. Example usage:

> necessarybits(640)
10 bits are required to store values up to 640
2 ** 10 = 1024

> print tobinary(46)
00101110

> print frombinary('1100_1100') 
204

> pattern('00rrr000', True)
  r is a 3bit number
  Packing:
  assert(r<8);
  unsigned char packed |= r<<3;
  Unpacking:
  unsigned char r = (packed & 0x3f)>>3; //packed & 0b00111111

> pattern('00000bbb')
  b is a 3bit number
  Packing:
  unsigned char packed |= b;
  Unpacking:
  unsigned char b = packed & 0x7; //packed & 0b00000111

I find "00rrr000" to be a lot clearer than '(packed & 0x3f)>>3' .

Python source
(34 lines of quick/unpretty code)

Midi (part 4)

2009-03-31T23:31:00.000-07:00

Today I released a new project, bmidi to wave.

It can be used to:

Turn midi files into great-sounding wav and mp3 files.
Play midi files, especially if you are unsatisfied with your current midi out quality.
Get information about SoundFont files and preview their voices.

You can find high quality SoundFonts online, and play each instrument in the midi with the SoundFont of your choice, resulting in the best possible sound. Use the mixer to fine-tune the volume and pan of each channel. Also, you can see a score view of notes in a particular track.

It is essentially a frontend for Timidity, the program that does the actual playback. Instead of having to edit the configuration files by hand, though, there is a gui.

This is a program I've been meaning to write for a long time. I first had the idea and initial designs in 2002, when midi files were more common. It didn't take very long to write.

Process management in Python is not too bad thanks to the subprocess module, which has a good interface. I also learned about Python threads through this project, primarily because one wants a responsive GUI while the song is playing and the time slider is moving.

Surprisingly, one of the more complicated parts of the program was allowing playback to start other places in the song. Timidity doesn't do this, and so I have to create a temporary truncated midi file for it to play. I would just chop off all events before a certain time, but because events like instrument change can occur at any time, all of the instruments would be wrong, let alone tempo and pitch bend. Tempo changes can occur at any time, and so it is not simple to correlate a midi tick with clock time.

Midi is a compact, but pretty well-designed format. Not many binary formats from 1982 are around today.

MS Paint Animation

2009-03-31T23:24:00.000-07:00

I gave MS Paint the ability to make animations and save them as .avi files.

I wanted to write a "flipbook" program, where you could draw a series of frames and create a simple animation. I think this type of program could be fun for kids.

I was about to write the program in Pygame, but found myself re-implementing many of the standard bitmap editing tools. It's easy to make a rectangle and oval tool, but I didn't really feel like making the fill tool or selection tool. So, instead, I used MSPaint as part of the interface to the program. (This is completely a hack, and the resulting program isn't robust, but it was kind of interesting to do). See a video of how to use it - you can move from frame to frame, duplicate the current frame, and play the animation.

I'm trying to make this look like just one program. A lot is going on behind the scenes. The program is a c# app that, first, launches Paint. It has a window style that causes it to be on top of other windows. The program uses many Windows API SendKey calls to send key events to Paint. When you move from one frame to the next, it does the following:

Tell paint to select all (Ctrl A), and cut (Ctrl X)
Take that image from the clipboard and save it to a .png file
Open the next .png file in memory and put it in clipboard
Tell paint to paste (Ctrl V) and deselect (Esc)

The other operations are done with a similar series of events. I had to tune the timing; the c# program sleeps while waiting for Paint. The play preview actually opens up a borderless c# window that is positioned so that it appears above the image, and cycles through the images.

It ended up working. The Win api gives you almost too much to play with. Now I know that c# apps can send simulated keystrokes to other processes, for semi-practical purposes.

Fishsquish

2009-03-20T22:05:00.000-07:00

I made an arcade-style game. You have to quickly out-maneuver your enemies and push blocks to squish them.

I was influenced by an old Mac shareware game, but I've added some twists. The blocks have numbers, and if you can add to 15, it will stun your enemies and give you points.

The game is written using Pygame. I've also ported it to the One Laptop Per Child XO.

I'm going to replace the graphics and sound effects; the ones there now are essentially placeholders. I'll also rewrite some of the levels.

Download. To play it, you need a recent version of Python, and for Pygame to be installed. (Sorry, if you don't already have Pygame you'll have to get it.) Works in Windows and Linux.

When the game is more complete I'll post a Windows binary.

Midi (part 3) Tunescript

2009-02-22T21:15:00.000-08:00

Here is another midi project done in my spare time. Tunescript is a musical toy, where you can enter a list of notes to create a song. Unlike other interfaces like this, though, tunescript supports a lot of features like multiple tracks and instruments, chords, percussion, accented notes, and even pitch bends. Also, I put much thought into the syntax.

For a lot of information, many examples, and to download, visit this page.

It is pretty fun to invent a domain specific language. Because the language doesn't (yet) have nested constructs, I don't need full parsing. I came up with a nice way to interpret the input. It works kind of like a finite state machine that is receiving a stream of instructions. For example, the character 'b' can mean either flat, as in 'Ab', or the note 'b', but there is no ambiguity, because the symbol 'A' causes a transition to a state that can accept the 'b'. Adding multiple tracks ended up being pretty simple, because I just use simple string operations to split the tracks.

In more detail, the core of my interpreter looks something like this. The use of the while loop isn't very good and should probably be made into a for loop, but for some reason I was thinking of gotos, perhaps because of the underlying finite-state-machine influence.

...main loop...
  while s!='':
    result, s = self.pullFullNote(s, track)
    if result: continue
    
    result, s = self.pullFullNoteSet(s, track)
    if result: continue
    
    result, s = self.pullFullModOctave(s, track)
    if result: continue
    
    #if i get here, i couldn't interpret something, throw an error.
  
def pullFullNote(self, s, track):
  if it is not a note,
    return False, s
  
  #otherwise, consume some of the characters from s
  next_s = s[2:]
  
  #add the note to the track
  self.trackobjects[track].addnote()...
  
  return True, next_s

What is nice is that this pattern can be followed repeatedly on smaller levels. The pullFullNote() can call pullPitch() or pullVolumeDuration() in just the same way, and those can themselves call pull functions. If pullVolumeDuration() doesn't see a match, it simply returns False with the original string given. Essentially, the benefit is that there is no need to be explicitly asking "can the next thing be a note?", because the pullNote style functions will smoothly drop through when the next thing is not a note. I don't think I'm explaining this well, but it is all there in interpretsyntax.py if you are interested.

Midi (part 2) Scoreview

2009-02-22T20:42:00.000-08:00

For fun, I wrote a program that visualizes the contents of Midi files.
The "score view" is just a Tkinter canvas on which lines and ovals are drawn. None of the graphics are bitmaps (except the clefs), which means that there is freedom to quickly zoom in and out. The sharp signs are actually the text "#" drawn at that point. Writing a custom coordinate translation made this code so much easier. When I specify y coordinates, they are given in units where 2 units is the height of between staff lines. So, moving a note up or down just means incrementing or decrementing its position, and only the lowest level of code needs to know about the actual pixel coordinates.

This tool can be a useful way to explore the contents of a midi song. Besides showing the score for a track, it can also get channel information:

Also, one can view all of the midi events in a track, in a human-readable format:

For a lot of information, and to download, visit this page.

If you've been wondering, yes, the eventual goal is to create a midi editor. This project isn't high priority, though.

Midi (part 1)

2009-02-15T21:41:00.000-08:00

I've been playing around with MIDI files lately.

MIDI files are essentially a list of notes with associated timing, and in the 90s were popularly used to make and share music. They can be easily made with a synthesizer and a computer. A drawback, though, is that the songs sound different if played on different computers. For example, different sound cards have different interpretations of what the "acoustic grand piano" voice should sound like, and the midi file itself does not contain the audio sample data. However, midis can be programmatically generated, and one can change tempo and pitch without losing quality. After broadband internet and mp3s became common, most people stopped using MIDI, although it still finds a use in music notation programs.

Unfortunately, these days, new computers come with awful-sounding software MIDI instruments, creating the false impression that "MIDI" is synonymous with "cheap, bad audio quality." In fact, there is nothing inherently bad-sounding about MIDI music, and with a set of good SoundFonts, it can sound very good.

Anyways, here are some Python scripts that can be used to create midis. The interface is not the best, but it was very quick to implement. Examples:

b = BMidiBuilder()
b.note('c', 1) 
#the 1 means the note's length is 1 qtr note
b.note('d', 1)
b.note('e', 1)
b.note('f', 1)
b.note('g', 4)
b.save('out.mid')

This plays part of a scale. To play a chord, "rewind" can be used to go back and lay more notes on top of existing notes.


b = BMidiBuilder()
b.note('c#', 1)
b.rewind(1)
b.note('f', 1)
b.rewind(1)
b.note('g#', 1)
b.save('out.mid')

Two tracks can be joined, to make a little tune:

tr1 = BMidiBuilder()
tr1.setInstrument('acoustic bass')
tr1.note('c3', 2)
tr1.note('d3', 2)
tr1.note('e3', 2)
tr1.rest(2)
tr1.note('f3',2)

tr2 = BMidiBuilder()
tr2.setInstrument('ocarina')
tr2.note('e4', 2)
tr2.note('f4', 2)
tr2.note('g4', 2)
tr1.rest(2)
tr1.note('a4',2)

bbuilder.joinTracks( [tr1, tr2], 'out.mid')

Also, there are a set of classes in bmidilib.py that can build a midi file and any type of event, like percussion, modulation, metadata, or pitch bends.

Download, tested in Python 2.5

Tonight I wondered what it would sound like to play the same note on the 127 general midi instruments. The result sounds interesting.

b = bbuilder.BMidiBuilder()
b.tempo = 400
for i in range(127):
  #insert a raw instrument change event
  evt = bmidilib.BMidiEvent()
  evt.type='PROGRAM_CHANGE'
  evt.channel=1
  evt.data = i
  b.insertMidiEvent(evt)
  b.note('c3',0.4)
b.save('cool.mid')

Hear it.
(Sound depends on your midi device, I don't recommend Quicktime so you may find it better to download this file and open it elsewhere).

Minimath

2009-02-01T18:22:00.000-08:00

Here is a long-term project of mine that still isn't finished, but is starting to become useful. I started this in a computer science class last year, so not all of it was done on my own time. At Olin, sometimes I'd like to have the software equivalent of my TI calculator. Matlab can be useful, but takes a while to load and cannot be described as light-weight. So, for quick calculations, I made Minimath, a small command line interface to evaluate math.

The main design goal was to save typing for commonly-occuring tasks. As you can see, the UI is pretty sparse now, and that is on my list of things to improve.

Features

Fills-in incomplete expressions. It is perfectly ok to evaluate "sin(pi" without the closing paren, because it will understand what you meant.
Line history, with arrow keys. Control-Up and Control-Down search history based on prefix like Matlab.
Supports complex numbers, saving values in variables.
You can press Alt-. to create a "->" symbol to store values, like a TI 83.
"ans" refers to last result.
If the first key you press is an operator, it fills in the "ans" like a TI 83. This one saves a lot of time.
Any valid Python expression can also be evaluated.
Pressing the "\" key (while not in a string literal) creates a lambda symbol, so that expressions like "f = λx.x+2" can be used.
Pretty print, which behind-the-scenes is parsing the expression, creating and rendering a temporary LaTeX file.
Uses Numpy library which provides many math functions.

Another feature is variable substitution. Pressing alt-, makes a "<-" symbol that can be used to subsitute values into an expression. For example, the result of "2*x^2 + 3*x <- 4" is 44.

Added Syntax

The symbol "^" now is exponentiation.
The ternary expression ? : can be used as in C.
The shortened "for(i,5)" can be used in place of "for i in range(5)".
Syntax for making arrays: "arr = a[1 2 3]" and "arr = a[1 2 3;4 5 6]". (Note that arrays are different than Python lists).
"i[0,4,10]" is like Matlab's linspace, 10 elements equally spaced from 0 to 4.
"i[0..4]" is an inclusive range, the result is [0,1,2,3,4].
It allows more items on one line than Python, just use semicolons. In particular, something like "for val in array:t+=val;print val" will work all on one line.

In the future, I plan to add more-advanced interpretation. For example, the string "3x4" could be recognized as "3*x^4", and "4(x+3)" to "4*(x+3)" Also, I should integrate Matplotlib or something similar.

AutoShoop

2009-01-23T23:29:00.001-08:00

An alternative to developing new technology is to apply existing technology in a new way. I was thinking about face recognition software a few days ago, and thought of a fun application (this isn't a serious project at all, by the way). So I quickly wrote AutoShoop, that uses a face-detection algorithm to draw "shoop da woop" shapes on people's faces. In other words, it automatically turns this:
into this: This works automatically - no Photoshop needed! I could have spent some time making the results better, but that's not really the point. It's more of a proof of concept.

autoshoop.zip (Windows GUI binary and sample images)
autoshoopsrc.zip (C# source)

I didn't write any of the face-detection part; I simply used fdlib. Your results may vary; I found that for some reason fdlib sometimes has a hard time finding faces in certain photos. When it works, though, it works pretty well.

Strangeparse

2009-01-14T17:21:00.000-08:00

Let's say I want to be able to parse an arbitrary expression like

f(f( a+f(a * b * f(c))))

where a, b,c are variables, and f is some function. I want to make a parse tree, and possibly to transform the tree. Last night I thought of a very unorthodox way to do this.

I've heard of yacc/lex, pyparsing, and Python's ast. However, for what I have in mind this is all I need:
- Python supports overloading operators.
- Python has an "eval" for dynamically running code.

My idea is to create Python objects for f, a, b,c, and then *eval* the expression as if it were Python code. The objects I create will have their operators overloaded so that a+b, for example, returns an expression like ['+', a, b]. Here's an example that supports addition, multiplication, and functions taking any number of arguments. (Adding the rest of the operators is simple).

class FunctionSymbol:
  def __init__(self, name):
    self.name = name
  def __call__(self, *args):
    return SubExp(self, list(args))
  def __str__(self):
    return 'FN_'+self.name

class VariableSymbol:
  def __init__(self, name):
    self.name = name
  def __add__(self, other):
    return SubExp('OP_ADD', [self, other])
  def __mul__(self, other): 
    return SubExp('OP_MULT', [self, other])
  def __str__(self):
    return 'VAR_'+self.name

class SubExp(VariableSymbol):
  def __init__(self, op, args):
    self.op = op; self.args= args
  def __str__(self):
    return str(self.op) + '(' + ','.join(map(str, self.args)) + ')'

def strangeparser(s):
  #parse something by evaluating it as if it were Python code
    
  symbols = {}
  #create objects for the symbols in the string 
  snospace = s.replace(' ','').replace('\t','') + ' '
  import re
  for match in re.finditer('[a-zA-Z_]+', snospace):
    strfound = match.group()
    if strfound not in symbols:
      #assume that if the next character is "(", then it is a function
      if snospace[match.end()]=='(':
        symbols[strfound] = FunctionSymbol(strfound)
      else:
        symbols[strfound] = VariableSymbol(strfound)
  # evaluate it
  try: 
    return eval( s , globals(), symbols )
  except Exception, e: 
    print 'Could not parse. %s' % str(e)
    return None
  
def main():
  tree = strangeparser('a+b+c')
  print tree
  # OP_ADD(OP_ADD(VAR_a,VAR_b),VAR_c)
  tree = strangeparser('f(f( a+f(a * b * f(c))))')
  print tree
  # FN_f(FN_f(OP_ADD(VAR_a,FN_f(OP_MULT(OP_MULT(VAR_a,VAR_b),FN_f(VAR_c))))))

Also, I've written code that turns this tree into a sequence of simple operations. Coincidentally, I think this could be used to write a compiler. I haven't read any books about that, though.

input:
 f(f( a+f(a * b * f(c))))

output:
 i1=OP_MULT(a,b);
 i2=FN_f(c);
 i3=OP_MULT(i1,i2);
 i4=FN_f(i3);
 i5=OP_ADD(a,i4);
 i6=FN_f(i5);
 i7=FN_f(i6);
 return i7;

I'm working on a way to conserve the temporary variables used here, because there is probably a way to reuse them after they aren't needed. What I do is go down to the bottom of the tree, find something that can be evaluated, and replace that deepest node with a temporary variable. I then repeat that process until the whole tree has been "flattened".

Homepage

2009-01-01T13:06:00.000-08:00

On the internet, I now have a place that I can call my home. I've uploaded an initial version of a personal website.

It can be seen at http://b3nf.com.

(The section called "Recent Experiments" consists of links to this blog, but the other sections like Projects are new. There's a lot of content to explore.)

I've been working on this occasionally over the course of a few years, which is why the site doesn't seem very unified yet.

I intend to keep this blog active, though, so stay tuned.

Huffman coding

2008-12-21T14:08:00.000-08:00

I've been playing with Scheme a bit. After hearing about Huffman compression in a lecture, I first wrote something in Python, but noticed that the recursion I used lent itself well to a functional language, especially where tail-calls were optimized. So I wrote this:

I've used it to construct a table for 9000 symbols with no problems, so it works pretty well. Can be downloaded here.

ISM, an intermediate level language

2008-11-15T22:39:00.000-08:00

For our Computer Architecture class, a partner and I created a MIPS cpu in Verilog. This was a really cool project that deserves its own description, but for now I'll focus on something I made while testing the cpu. The cpu runs MIPS assembly code. Writing assembly is not bad for simple tests, but when I started to write more complicated programs, I got tired of remembering what I was using $s0 for and so on.

So, just for fun, I quickly wrote a Python script to translate assembly-like code into assembly. The small language I designed is an intermediate between higher-level code and assembly. The syntax is more like a higher level language, assigning values with "a=b" or adding with "c = a+b". It's not a compiler, but doesn't really need to be, and with too much abstraction one would be better off writing in C anyway.

The cool part about the project is how quickly and naturally the code turned out. It only took an hour to have a fully working version that understood the opcodes, and had useful error messages for syntax errors. The code just flowed quickly as I found ways to reuse code and simplify the problem.

For example, I needed to split each line of code by tokens. I came up with a creative way to do this - Python has a built-in way to split a string based on whitespace, " 'a b c d e'.split() " evaluates to "['a','b','c','d','e']". So in order to split on both + and - tokens and whitespace, I did "input=input.replace('+',' + ').replace('-',' - '); result=input.split()". By surrounding each occurrance of '+' with whitespace, now the string is split by both whitespace and tokens, so that a+b and a + b are both recognized as ['a','+','b']. (This could also be done by splitting on a regex, but that would be slightly more complicated).

The first, one-hour version, understands code like:

//add numbers from 1 to 25 and put result in sum.

registers i, const_one,sum,highest
seti const_one=1
seti sum=0
seti highest=25
seti i=0
LOOP:
 add i=i+const_one
 add sum=sum+i
 bne (i!=highest) goto LOOP

Then, later, I started to add more features. I added syntax shortcuts like a++, and simulated more types of branching even though our cpu only supported bne. I also added inference, where each line is checked to infer which operation you are trying to do. For example, if the line is "c=a+b" it is clear that you are doing an add instruction, so you don't have to type "add". Also, it now understands simple loops and if structures, translating them to assembly. It looks like Python if you squint.

// find prime numbers from 2 to 100.
// Place the largest found in result.
registers i,tmp, base, limit, result

// clear memory
for i,300,0
  dataWordIndex[i] = zero
endfor

limit=100
for base,2,100
  // check if we've already seen this number come up
  tmp = dataWordIndex[base]
  (tmp != zero) goto CONTINUELOOP
  
  // check off multiples of this number.
  i=base
  INNERLOOP:
    i = i + base
    dataWordIndex[i] = one
    (i < limit) goto INNERLOOP
  
  CONTINUELOOP:
endfor

// put largest prime found into result
for i,100,2
  tmp = dataWordIndex[i]
  if (tmp==zero)
    result=i
    goto DONE
  endif
endfor

DONE:

It was fun to come up with syntax for this. Branches are done with the unique, yet readable syntax "(a==b) goto Label". Array-like syntax is used for accessing data memory, like 'dataWordIndex[i] = b'. (dataWordIndex means that the index is automatically multiplied by four, so that it can be used as an array of 32 bit integers.)

When the script runs, it also prints out Verilog $display statements, which can be placed in the Verilog code to see the values of the registers.

Here is the code. ism_simple.py is the first version. I realize that it won't be useful unless you have a mips assembler and cpu.

Rickroll Detector

2008-11-02T16:46:00.000-08:00

Some people evidently don't understand when a meme is dead, or deserves to die. Rickrolls have been around for far too long and have even been picked up by the mainstream media. It's just not really funny anymore.

Today I was kind of bored and made this in a few hours. It's a system for checking if a link is a rickroll. You provide a URL, then some audio analysis is done, and the result is a plot showing whether or not it was a rickroll. What's nice is that it will also detect spin-offs like Barak-roll, scary roll, and so on.

How it works:
A Launchorz script directs what happens.
First, your audio is muted automatically.
Then, behind the scenes, the url is opened in Firefox. The program Total Recorder is used to capture the audio played by the webpage.
The page is closed after 15 seconds of capturing audio.
The audio is saved as a wav file in a temporary location, and your audio is unmuted.
Then, a MATLAB script is used to analyze the audio.
The audio is normalized to approximately the same volume.
Then, the cross-correlation is taken between a reference Rickroll audio and the recorded audio.
If there are peaks in the cross-correlation above around 200, then it is likely the page contained a Rickroll.

Results: After adjusting of parameters in the MATLAB code, the results are pretty good.

"Warning: rick-roll detected"

"Safe: no rick-roll detected"

Kylie Minogue's "I Should Be So Lucky".

(The mostly-evenly spaced peaks correspond with the steady beat in the music.) The results would probably be even better if the comparison was done in frequency, instead of in time. But I'm not about to waste any more time than the few hours I put into this.

Here's the script I used but it needs Launchorz, MATLAB, and the shareware program Total Recorder.

Mailman Scraper

2008-10-27T16:03:00.000-07:00

I wrote a script to scrape messages from mailing-list archives and store them in a MySql database. It can retrieve message, author, and date information for everything sent to the list.

Code here. GPL, Requires PHP5 and mysql. You'll have to read README.txt for instructions.

Intended for use with a Mailman list, one that looks something like:

Because this just uses regular expressions to scrape the pages, it's kind of fragile. It makes some assumptions about the format of the page and might not work with other versions of mailman.

I've found this useful for a few projects. One result is a script that tracks list activity (and shows a flame-meter when the list gets intensely active; the current state is ranked from serene to mayhem). I'm also creating a site that allows searching the list archives, as well as voting on the quality of information and adding tags. Of course, one can also use this to create a Markov model of a list... but I'm not going there.

Documentation Viewer

2008-08-13T12:56:00.000-07:00

This project isn't very exciting, but it will be useful to me. I wrote a documentation viewer that displays documentation information in a tree control.

I spent a lot of time going through the Python library documentation, acquiring what I thought was important, and re-organizing all of the modules into my own categories. This also required writing Python scripts to turn reStructuredText, the loose and readable format of the Python documentation, into the xml format used by the doc viewer.

I also organized all of the documentation for C.

One cool feature is that it can communicate with the SciTE code editor. So, when run from LnzScite, it appears like a tool window, and you can double-click a function in the browser, which will insert the function's name into the editor. (Watch for this in Launchorz 0.3). A planned feature is to be able to look up documentation on the currently selected function.

I wanted this program to feel small and lightweight, so I did this: the nodes are created dynamically, from the xml, when you expand a parent node. This means that the entire documentation isn't loaded into memory and no unneeded TreeNodes are created. I also spent time tuning the xml-parsing code to be very fast, using C#'s stream reader which avoids DOM overhead.

You can download the Lnz Doc Viewer here, which includes documentation for C, Python, and LnzScript (unfortunately only for Windows). The source, as usual, can be found from the project page.

As an aside, I'm starting to take advantage of some of the benefits of xml. In the source for Launchorz, there are special comments for the provided functions. Everything starting with /// is treated as a documentation string, and can be processed by a Python script into an xml file. This xml file contains the prototypes and docs for every function in lnzscript - and the same file is used by a c# program, a c++ program, and a wsh script. And it doesn't stop there - if you open the same xml file in a web browser, it nicely renders the documentation with xslt!

AI Scheme

2008-08-08T13:42:00.000-07:00

Just for fun, a few days ago I wrote a minimax AI algorithm in Scheme. This was mainly a way to become more familiar with writing in Scheme, and so I wrote it from scratch. I had written pieces of Scheme a year ago but wanted to write something more practical. Writing in a functional language is fun because it pushes you to see problems from a new perspective. (For those unfamiliar with the concept, of the code I wrote there are no variable assignments, for loops, while loops, or C-like arrays). Also, when finished, I was able to format the code nicely.

To use this algorithm, you can provide definitions for create_new_table,get_open_spaces,place_at_position, and is_winning, and that will be all you need. This zip file contains the complete program and an example game implementation.

If I get tired of S-expression syntax, Javascript is actually a good language for functional programming. It has the ability to do concisely express things like function() { call_something(); return function(){ do_something(); } }(); or function adder(x) { return function(y) {print('!'); return x+y}; } f = adder(1); f(1);. In fact, it did not take very much work for all of the The Little Schemer examples to be written in JavaScript; see Douglas Crockford's page and this. Python's lambda, on the other hand, is intentionally limited to containing one expression, and there not seem to be any convenient way to create an anonymous inner function with scope.

Version 0.2!

2008-08-04T20:12:00.000-07:00

Launchorz 0.2
Documentation

I've just released version 0.2 of Launchorz. It comes with significantly more features, and even a dedicated code editor. If you're using Windows, it will save you a lot of time. Try it!

The code editor is a custom build of Scite. I've added autocomplete and tooltips to make it faster to write scripts.

See screencasts here

Download it here (under featured downloads)

Launchorz

2008-07-10T23:12:00.000-07:00

Release!

For the past few weeks I have been working on a project for Windows automation. The result is Launchorz, Powerful JavaScript libraries for Win32 automation.

Look at this!

Process.open('notepad.exe')
Mouse.move(1,1);
Time.sleep(500);
Keyboard.send('hello!')
Dialog.askYesNo('Question','Did you expect this to happen?');

LnzScript is the language of the Launchorz project. It is JavaScript (run locally, not in a web browser) with libraries for simulating keystrokes, mouse movements, working with files, and a lot more.

Read the actually substantial documentation:
http://b3nf.com/codepages/lnz/

Try it now! Download and get the source from Google code:
http://code.google.com/p/launchorz/downloads/list

Look at what it can do:
Reference

One cool aspect of the project: documentation is written inline with the C++ code. Then, a Python script creates an xml file from this documentation. This same xml file is used for reading by C++, C#, and even rendering to the browser! I wrote an xsl transform that renders the documentation, so that it can be seen in a browser. If you look at the source, you'll notice that it is xml.

AutoIt exists and is good at what it does. However, its syntax and minimal data structures will not do for non-trivial programs. More of my rational is given in the documentation.

Leave a comment, or send me an e-mail if you are interested in joining the project. Please try it and give feedback - I will consider feature requests.

Blinkbeat

2008-07-06T15:27:00.000-07:00

Here is another of my audio experiments, called Blinkbeat. It uses the Caps/Num/Scroll lock lights on your keyboard to blink along with the song you are playing! Click on the picture to see a video (Youtube):

The FFT is used to find the energy at different frequencies. What I display is kind of like a histogram of the frequencies.

I have also added a beat detection option, which is not finished but seems to do a decent job. For beat detection, I divide the song into short segments, and use the FFT to find the low-frequency energy in each segment. So, I now have another signal in time, which is the low-frequency-energy over time. Finally, I take a second FFT of this new signal, which is finding the frequencies in this signal. I estimate the rhythm of the song to be the peak in these results, and return the result in BPM.

Downloads

Windows binary

Check out the source with:
svn checkout http://yaalp.googlecode.com/svn/trunk/csaudio/

Known issues: The normalization of lengths isn't perfect. If you try to play a long clip, the lights and the audio will eventually lose sync. Also, I draw the bars by changing the dimensions of several button controls :).

WaveAudio Developments

I've also been working on the WaveAudio sound library in C#. It's pretty nice to be able to write:

Sine note = new Sine(440.0);
WaveAudio wave = note.CreateAudio(1.0); //1 second
wave.Amplify(1.5);
AudioPlayer pl = new AudioPlayer();
pl.play(wave); // and now you hear it!

I spent a lot of time yesterday writing some really sweet code for synthesizing audio. By the end of the day I found out that what I had sounded a lot like the cheesy "choir" effect on old keyboards!! Still, this is pretty cool, and there are many more parameters to tweak. I'm owe thanks to Wikipedia and Wikibooks for giving me ideas.

I added an algorithm for autocorrelation pitch detection, which works pretty well. It can tell what pitch I'm singing, and works on various instruments as well.

As usual, source at http://yaalp.googlecode.com/svn/trunk/csaudio/

Audio Experiments!

2008-06-27T14:58:00.001-07:00

This program is a little interactive demo of 3 "audio experiments" I came up with. (An example of its sounds). My goal here was to create interesting sounds, experiment with FFTs, and test my digital audio code - but more on that later.

First, there is the "Vibrato Lab". A quick overview: Wav files store a sound as a long list of numbers, representing air pressure vs. time. If the computer plays through this list of samples at a faster rate, we hear a higher pitch. For example, playing every other sample results in something sounding an octave higher and twice as fast. If the samples are played back at a varying rate, the pitch of the output varies, making a comical wavy sound. This is how I wrote a vibrato effect.

When testing the vibrato effect, I found that it could sound interesting if the vibrato effect were applied twice - something like vibrato(vibrato(sound)). So, this is what the vibrato lab does. Use the sliders to change the width (how widely the pitch varies) and the frequency of oscillation. Use the checkboxes to enable another vibrato effect. Play with it!

Next, the "CrFeedback". Have you ever played with video feedback, where when you tilt the camera the picture spirals and twists? When experimenting with audio code, I invented an effect that I like to think of this as the audio analog of those spirals. In this case, the song spirals out of control and degenerates into interesting noise. What you hear is like the sum of the song and many slower versions of itself. Play with the parameters - the "right" settings seem to be dependent on the clip you choose.

Finally, "Frequency Sketch". Last semester I took a course in Signals and Systems. Fourier transforms and the like are very cool, and the math was interesting. Most of the course dealt with signals in the context of voltage and current, but I wanted to apply what I had learned to audio. I wrote fourier transform code, and played around with discrete fourier transforms of audio significantly. As the name implies, the FFT is a faster algorithm for this, and so I replaced my fourier code with some FFT code by Don Cross, originally in C. Anyways, in this experiment, you can draw in the frequency domain, and hear the result! I've wanted something like this for a while, and there is still much left to study.

Microsoft Paint is the user interface for Frequency Sketch :). If you draw red pixels or lines on "input.png", you can hear the results. For example, drawing one red dot creates one sine wave, and so you will hear one pitch. The axes in blue show Hz. Note that the highest red pixel is chosen for a given frequency if there are more than one red pixels in a column. So far I've created ambient, flute-like, and eerie siren effects, but this is just the beginning.

All of this was accomplished in a few days - using a library of digital audio code I've been working on for the past few weeks. I created a project in C# called CsWaveAudio; features include saving and opening wave files, synthesizing sounds, FFT, and certain effects. One interesting part of the library is that it stores samples as doubles, between -1.0 and 1.0. This makes it much easier to do calculations - and when writing effects you don't need to consider whether you are in 8-bit or 16-bit. The library also includes code for some "instruments" made from adding sine waves.

Downloads

Windows binary

Examples of sounds

CsWaveAudio, a C# digital audio library, GPL

And, get all of the code: svn checkout http://yaalp.googlecode.com/svn/trunk/csaudio/

More notes: in the vibrato lab, the "tremolo" option creates oscillation in amplitude, not in pitch. Also, try clicking numbers to see what happens. The code for the CrFeedback effect is in the readme file - check out the svn source to modify it. There is a "randomize phases" checkbox in frequency sketch and I'm still not sure why this makes such a difference. Beat frequencies can be created because of the spacing between pixels in the input image. Maybe I should look into interpolation.

LaTeXinWord

2008-06-23T23:28:00.001-07:00

When I have time, I type up notes from school in LaTeX, so that they will be archived and legible for the future. This works ok, but I use many quick illustrations and diagrams, which are a pain to add to a LaTeX document (or at least are in any editor I've used). Also, even when the picture is saved, and in the right format, you can't really control positioning. By design, LaTeX has its own ideas about where it thinks your figure should go. This is good for actual "figures" as you would find in a paper, but I want my little diagrams to be inline with the text and not on the next page. In Word, by contrast, I can select an image and Ctrl C, Ctrl V it right into the document, but LaTeX's formatting of formulas is so much better.

As it turns out, I can have a combination of the two. There is a good open source project, LatexInWord which I recently discovered. Now I can keep the formulas I was using but have more control over layout of pictures. The interface is good - all one needs to do is press Alt-L to insert Latex. Also, I can have this open side-by-side with Lyx in view source mode, or another editor, and copy and paste. (There appear to be similar macros for OpenOffice, like this.)

Of course, I'll still write my actual papers in standard LaTeX, but for my personal notes, this should work well.

Tonight I wrote a quick macro to be used with LatexInWord. It prints out the LaTeX source for all of the formulas in the document. I thought this would be useful to have for archival purposes (in the future I might not have LatexInWord or Word so a plain text copy is good). This is basically my first Word vba script, but it worked when I tested it.

Sub ExportLatexAsText()
    Dim strRes As String
    Dim i As Integer
    Dim newline As String
    newline = Chr(13) & Chr(10)
    i = 1
    For Each currentShape In ActiveDocument.InlineShapes
        If currentShape.AlternativeText <> "" Then
            strRes = strRes & newline & newline & "Formula " & i & newline
            strRes = strRes & currentShape.AlternativeText
            i = i + 1
        End If
    Next
    Selection.Text = strRes

End Sub

You can add this to the document under Macros. Just start editing an existing macro, and when you're looking at the source, put this subroutine in.

Googlecalc

2008-06-20T08:15:00.000-07:00

This has been done before several times, but usually in Perl. After reading a version by Matt Sparks, I quickly wrote a C# version. I think this is something that will be useful. You type in an expression, which is sent to Google, and the result is printed back.

Bin (Windows exe) Source, project file is Vs2008 but the source should work in 2005.

On another note, while I have enjoyed reading entries in the Obfuscated C Code Contest for a while, there is another interesting contest that sounds just as fun. The Underhanded C Contest is a "programming contest to turn out code that is malicious, but passes a rigorous inspection, and looks like an honest mistake."

Another clever contest is the Obfuscated V contest in 2004, where contestants wrote short programs that appear to simply count votes, but actually influence the results.

Summer

2008-06-19T08:02:00.000-07:00

I have been writing code, but that will have to wait. I just needed to post something since it's been a while.

In Java, Math.abs can return a negative number (!). I heard about it from here.

Python 2.6 is in beta. In Python, last fall Guido talked about the GIL. Now I am interested to see a "multiprocessing" module which "supports the spawning of processes using a similar API of the threading module". This is pretty cool - it will allow programs to take advantage of multiple processors, while maintaining the GIL.

A Python 3k hack from here. At least on the Python 3k I'm using , __signature__ isn't available yet, so this doesn't work yet. Annotations can be useful though.

#posted by Nick Coghlan
#on Python-3000 list,
#http://mail.python.org/pipermail/python-3000/2006-May/002033.html

#Apparently __signature__ hasn't been added yet. This won't work yet.

class Annotate(object):
     def __init__(*args, **kwds):
         self, args = args[0], args[1:]
         self.arg_notes = args
         self.kwd_notes = kwds
         self.return_note = None
         self.strict = False

     @classmethod
     def strict(*args, **kwds):
         cls, args = args[0], args[1:]
         self = cls(*args, **kwds)
         self.strict = True
         return self

     def returns(self, note):
         self.return_note = note
         return self

     def __call__(self, func):
         func.__signature__.update_annotations(self)
         return func

@Annotate(str, str, int).returns(int)
def f(a, b, c=0):
     # some operation producing an int. . .

@Annotate.strict(str, str, int).returns(int)
def f(a, b, c=0):
     # some operation producing an int. . .

I am currently working for Avid in Tewksbury, MA, as a "Media Engine Infrastructure Software Engineer Intern". It's going well so far as I dig deeper and deeper into c++.

Consonance

2008-04-28T12:51:00.001-07:00

When two notes of close frequency are played simultaneously, one can hear what is known as a beat frequency. Say two violinists are playing. One plays an A, 440Hz and the other is playing slightly sharp at 445Hz. One hears a 5Hz "beat" buzzing, that arises from the sum of the two sine waves.

When the two tones are very close, the sound is no longer unpleasant, and the result sounds like a "smooth", flowing note. When the tones are less close, one hears the "buzzing", vibrating beats. When the two tones are significantly separated, one simply hears two notes. In the 19th century, the physicist Helmholtz posed a theory: what if humans dislike the sound of beats, and that the more the beats are noticed, the more "rough" the sound is perceived. He developed a "roughness" curve based on some experiments:

Now, if we go back to the example of the two violins, we can predict how pleasant the two sounds will be to each other. This gets interesting, because a violin plays more than the fundamental note; harmonics are played also. So if the first violin plays an A, and the other plays a slightly offtune E, there will be roughness between the 3rd harmonic of the A (E'), and the 2nd harmonic of the E (E'). If the roughness for each interaction for 6 harmonics is summed, an interesting pattern emerges:

This figure plots the sum of roughness for 6 harmonics, when one plays a fixed note, and the other violin changes pitch. The peaks are areas of high roughness, and the valleys are lower roughness. The notches in this plot line up perfectly with the intervals we use in music! The central valley is the interval of a perfect fifth. The other dips are other familiar intervals. This offers an explanation of why certain intervals are more "consonant" than others, and more. In developing temperament systems, it was found that some approximations of notes are more tolarable than others. For example, we are very perceptive to a slightly-off 5th, but not to an adjusted 3rd. This might correspond graphically with the "steeper" valley of the 5th. Also, the shallower valleys reasonably match with what we consider less consonant intervals.

Using this, Helmholtz was able to explain quantitatively why a major 3rd played by a clarinet and oboe sounds better when the clarinet plays the lower tone (the clarinet sounds only odd harmonics).

The figure is a screenshot from a program I wrote to explore this. When you click on the plot, you hear the interval. It also includes a modern model of roughness, Vassilakis (2007).

Download (Windows, .NET 2.0) Source (including Matlab plots)

But do beats and perceived roughness cause dissonance, or are they just correlated with dissonance? Helmholtz's theory does not explain everything. Even when beats are eliminated, the intervals sound dissonant. The notes of our scale are also found in the harmonic series. One could alternatively say that notes are consonant when their harmonics match. This paper notes many criticisms of Helmholtz and the theory of roughness. I will have to study this further.

References: "On the Sensations of Tone as a Physiological basis for the Theory of Music" by Hermann Helmholtz, translated by Ellis
Roughness Calculation Model by Vassilakis, 2007.
Sensory Theories of Musical Consonance

Fun with Real-time Audio

2008-04-26T22:48:00.001-07:00

Over the past week, I've had fun with real-time audio. I'd worked a bit with sound in the past, but in Python, where synthesizing audio is noticeably slow. This time, I coded in C#, which is a lot faster and has access to DirectX. I use DirectSound to put raw bytes of data right into a buffer, enabling seamless audio.

After experimentation, I came up with a program that plays a continous tone. While it is playing, you can change the pulse-width and "smoothness", creating interesting sounds. Quickly changing pulse-width creates the illusion of motion. The "smoothness" parameter goes from sine wave-like to a square wave (approximated by quadratics). As another experiment, I added a joystick interface - if you plug in a game controller and open the program, you can use the joystick to control these parameters. I encourage the reader to think of more audio effects and interfaces.

I wrote a custom control plotting the waveform, which was useful. The program also contains my implementations of waves such as square, triangle, sawtooth, white noise, red noise.

As an aside, delegates in C# are very convenient, allowing you to easily store and pass refrences to methods. What is great is that there is so little code involved. Here's an example from my sound class:

// Takes integer index, returns double between -1 and 1
delegate double SoundDelegate(int i);
...
double timeScale = frequency * 2 * Math.PI / (double) 44100;
SoundDelegate fn = delegate(int i)
{ 
    return Math.Sin(i * timeScale);
};
return create16bit_sound(fn);

Notice how the anonymous function can even keep references to variables. It's better than a Python lambda.

Here is a sample. The real thing sounds even better, the rate of updating was limited in the process of recording this sample.

I found that smooth pitch-changing for real-time audio could be complicated. If you just change pitch, you hear a lot of "clicks" - the period doesn't line up with the size of the buffer, causing a click every refresh. I sidestepped this problem by only playing frequencies that fit into the buffer, but that's not a very good solution. If I took the previous phase into account, I could fix this.

Download (Windows, .NET 2.0, DirectX9) Joystick is optional
Source GPLv3

If you want to write DirectC audio in C#,the following may help: To get the Managed DirectX dlls, I downloaded the "DirectX 9.0c Redistributable for Software Developers", ran it, and opened the resulting ManagedDx.cab file. Also, using these in Visual Studio 2005, I would get an exception upon starting the program. One can disable this false excption in Debug->Exceptions->Managed Debugging Assistants, uncheck LoaderLock.

Maurader's Map Update

2008-04-15T14:32:00.000-07:00

Over 1/4th of the students at Olin are on the Maurader's Map!

We improved the location algorithm. It is successfully at room-level precision, which is really cool, and the accuracy is very good. As you can see, we've added the ability to have custom icons. The client runs on Windows, Linux, and Mac now.

And, you can actually use it to find someone. Now we just have to persuade the professors to use it.

gedit Regular Expression Plugin

2008-03-30T21:01:00.001-07:00

A friend told me that gedit was missing a regular expressions plugin that could replace. I use gedit occasionally, and so I worked on this plugin. It uses Python's good regular expression module, and supports backreferences, making it possible to do significant text processing.

This plugin is based on extensão para o gEdit by Daniel Carvalho. I fixed bugs, cleaned up the interface, moved the menuitem to the Search menu, added backreferences support, added replace all, and added an option for case-sensitivity. Also, the search mode is multiline, so ^ matches the start of a line. Download
To install, place the files in ~/.gnome2/gedit/plugins/. Then open gedit, choose Preferences from the Edit menu. On the plugins tab, you should see Regular Expression Replace in the list. Check to enable. Now, you should have a "Regular Expression" item in the Search menu. Tell me if you have any feedback.

Backreferences are very useful. In the screenshot above, I've written a regular expression for turning "one.tim" into "tim.one", and so on.

RenameCells

2008-03-22T20:25:00.000-07:00

Renaming files in Windows Explorer is somewhat slow - select, F2, type a new name, select the next file, and repeat. I thought it would be cool to instead use a spreadsheet interface - where pressing Enter drops you down to the next line.

So, I wrote RenameCells, a Python program for quick renaming. I also added features for batch renaming like Rename by Pattern, Replace, and Regular Expressions. You can see all of the changes in a grid before you press Rename. The grid interface also lets you copy and paste from Excel or another program. See the tutorial for information about all of this.
Tutorial explaining use.
Download for Windows (just unzip it and run RenameCells.exe)
Python source, cross-platform, requires wxPython.

The source should be cross-platform but I have not tested thoroughly except on Windows. If you change your mind you can hit Undo, and if something goes wrong, choosing "Repair" from the "Rename" menu will clean up temporary files.

Pythonpixels

2008-03-08T13:41:00.000-08:00

A few days ago, I wrote Pythonpixels, an original interface for image processing. (Download).

Let's say you want to quickly prototype a new imaging algorithm. As a simple example, you are increasing the Red channel of an image by 40. Typically, this would first involve quite a bit of code, in order to gain pixel-level access to the image. Also, once testing your project, you would need to set up a test framework and enter the debug/recompile cycle.

With Pythonpixels, this whole process is as easy as typing

map:
    R=r+40

Lower-case "r" means the old red value, and "R" means the new red value. That's all there is to it. To test the effect, type this into a box, press Run, and you see the results instantly.

If you wanted to create a gradient,

loop:
    R=x+y
    G=x-y
    B=0

(It's fun to experiment making patterns this way. In the examples that come with Pythonpixels, I played around with sin and cos as well to make funky patterns.)

Also, what you type is interpretted as Python code. (Any value > 255 or < 0 is truncated for you). So, you can include complicated logic, and read the output from print statements.

If you want to do something more advanced, the entire image is exposed as imgInput. The following example makes your image all wavy.

from math import sin, cos, atan2, sqrt, pi
midx = width/2
midy = height/2
nwave = 12
imgOutput = ImageChops.duplicate(imgInput)
imgInputArray = imgInput.load()
imgOutputArray = imgOutput.load()
twopiconst = 2.0 * pi / 128.0
loop:
    newx = x + nwave*sin( y * twopiconst)
    newy = y + nwave*cos( x * twopiconst)
    if (newy>0 and newy<height and newx>0 and newx<width):
        imgOutputArray[x,y] = imgInputArray[newx,newy]

Or hue shift:

loop_hsl:
    H=h+0.2

It comes with other effects, including convolution matrices, fractals, kaleidoscope, and posterize. Data-oriented operations work very well, too, like finding pixel values, statistics, or making a histogram. Other features include pasting an image from the clipboard and batch-processing a folder of images.

Try it out! Windows Download (3.7Mb, GPL). Unzip the file and run Pythonpixels.exe. Let me know what you think, and show me scripts you come up with.

Source Python 2.5 (GPL). Requires packages tkinter, python-imaging (PIL), python-imaging-tkinter (ImageTK).

You can check out the source at http://code.google.com/p/pythonpixels/.

More details: The keyword "loop" loops through every pixel, (providing the variables x and y), and if you assign to R, G, or B, the output value at that position will be changed.

The keyword "map" sets up a precomputed table for red, green, and blue values. This makes the effect very fast, but limits what can be done - the effect cannot depend on x,y position, and hsv or hsl cannot be used.

"loop_hsv" and "loop_hsl" work in the same way as loop but are in different color spaces.

Maurader's Map - In Use

2008-03-04T13:06:00.000-08:00

We've released a beta of the map, and people are starting to use it. (That's a real screenshot of the people online right now.)

Unplot

2008-02-23T17:41:00.000-08:00

Sometimes I want to "un-plot" data. I find myself in the situation where I have a plot of the data, but not the actual coordinates of the data itself. So, today I wrote this little tool for turning a bitmap image into the x and y coordinates of the curve. (Some Photoshop work may be necessary for cleaning out other lines in the image). It simply takes the image, starts at the top, and scans downwards until it hits the curve, and then works from left to right. The data can be saved as CSV, to be easily loaded into Excel or Matlab.

I've tested this on figures from research papers, and it works. This will be useful for recovering data from a figure when the original data has been lost. Also, I can use it to get audio data from Audacity.

Watch this screencast of it in action. This will show how to use it.

And here is the program (897K). Currently Windows only, but I can port it to Linux if there is interest.

WordMash

2008-02-23T17:19:00.001-08:00

In high school, I wrote a short JavaScript program to create Markov chains while waiting in an airport. The idea is simple but yields incredible results. First, you enter some lengthy text. A model is created by keeping track of all of the words that follow a given word. If there is a fairly large input text (Sherlock Holmes, or the Times), the slight amount of context will be enough to create sentences that (almost) make sense:

I told you yesterday, and I trust, with you, however, as I spoke, and it is clear and concise.

However, the randomness produces results that are often ridiculous!

Mr. Gordon, a retired Marine lieutenant general and a metal-schooled three-ax attack into songs that are both action-packed and gratuitously stylized. "Where Can I Stab Myself in the course of research for gut-level emotional impact," sheriff's officers said.

I recently made a site called WordMash where you can try it yourself, with texts like The Adventures of Sherlock Holmes. Best of all, you can paste your own text in, and see what happens. The code is all GPL, so have fun with it. Leave a comment if you come up with something good.

3 Windows Utilities

2008-02-12T12:46:00.001-08:00

First, a rich text-to HTML converter. You can use it alongside WordPad to get a ghetto Dreamweaver.

I was looking for a quick way to convert some RTF documents to HTML. Parsing the RTF was too much effort. Pasting into Dreamweaver seemed to strip formatting. I then thought of an idea that would make this very easy. You can paste rich text into a "ContentEditable" element in Internet Explorer, and it will retain much of its formatting - and then getting the innerHTML of that element produces the HTML!

Bold/italic/underline, fonts, colors, indentation, and even tables(!) are supported. I threw together a demo here. (Requires Internet Explorer). Also of note is this cross-browser rich text editor that also works in Mozilla using designMode.

Next, a small tool for finding colors. You know the eyedropper tool in Photoshop that can pick up a color from an image? This will do something similar for anything visible on your screen. It will grab the RGB value of the color just underneath your cursor, in any Windows program.

Download it here (zip, no installer). Run the program and press the space bar to update the color to be whatever color is beneath the mouse. The idea came from altAnswerColor from Altuit.

Finally, I use Microsoft Paint occasionally to draw simple lines and diagrams. To get arrows, I'll have to copy screenshots from Word or something. I wrote this small program to have quicker access to arrows.

When you click an arrow, it places an image on the clipboard that can be quickly pasted into Paint. Simple, yet useful.

The Marauder's Map of Olin

2007-12-23T00:48:00.001-08:00

A friend and I have been planning this for a few months. On a laptop, we can find the signal strengths of wireless access points, and use this information to determine location. A few days ago, I sat down and coded it, in time for Expo. My poster probably says it best:

Instead of using triangulation, it simply acquires a lot of data. (Triangulation did not work as well, because of the many walls and windows in our dorm.) The database simply records associations of a set of wireless signals with a name ("AC Room 318") and a point on a map. To look up a position, the server looks for a similar set of values with a distance formula, and returns the closest match. When the program is run, it recieves feedback from users, and every time adds a new association. Over time, the results get better and better. From successful tests, I think room-level precision may be possible.

We were able to figure out the right WMI query to find signal strengths other than the current connection (in Windows). I then wrote a small C# app that runs the query and prints the results to stdout.

A Python program gathers this data, taking the average of three runs, and sends it to the server. A PHP script forms a vector, thinking of each of the 76 access points as an axis, and looks for nearby vectors in the database. The location of the user, and status, is also stored in a centralized database.

Finally, in a web app you can view locations of everyone who is logged in. Hovering over the icons tells you who and where the person is. (Only if you swear that if you are up to no good).

Improbability

2007-12-10T23:39:00.000-08:00

I'm in ProbStat this semester. I didn't feel like working so I wrote a quick little program.

Tools like SurfStat are nice, but they aren't quite what I want. So, I wrote a similar web app, Improbability. You can tab through the fields more easily and simply press Return to evaluate. Also, there is a graphical display of the area under the curve (using CSS and transparency).

So far, just the normal distribution until I'm satisfied with the interface, but other distributions will be pretty easy to add. I just wrote this, and am open to suggestions as to making it better.

Math Console

2007-12-07T23:57:00.000-08:00

Here's my old Math Console.

Before I had ever used Matlab, I wrote something resembling it (in JavaScript, of all things). I used it at the time for my statistics class, and kept the code kicking around, but never got around to finishing everything that I had planned. (I had wanted to add many more statistics features). One of the factors was JavaScript's lack of support for overloading operators, which kind of stopped things. Also, there isn't really a convenient way to support complex numbers.

Today I made it (somewhat) cross-platform. Since this might be as complete as it will get, I'll call this the last version. Open the page and you can click a link to see a list of features and provided functions.

I still think this is a pretty cool project, and I am just now working on something similar in Python.

Tetris Overflow - On Camera

2007-11-13T17:00:00.000-08:00

As explained in an earlier post, in the Tetris game from WEP, the score overflows. I was able to repeat this a few times and it happened each time. Now, I've got it on camera (needed a lot of takes, so I have even more practice now).

Video

Look at the score.

201%

2007-11-12T17:40:00.001-08:00

(If you don't get it, it's a reference to a song).

Pyget

2007-11-03T11:35:00.000-07:00

I wrote a small program in Python for downloading files. (It is basically an interface for urllib, which does the real work). You can also use it from the command line with wget-like syntax.

It has some convenient features. If you have copied a url in the clipboard, it is automatically placed in the field, saving you a step. In the "Add..." dialog, you can specify a sequence of urls with the syntax "http://test.com/file_[0-4].zip", which expands into "http://test.com/file_0.zip", "http://test.com/file_1.zip", and so on. The most useful feature is downloading links from an html page:

Here's the code. You'll need a recent version Python and the wxPython GUI toolkit.

Quoteboard

2007-11-02T20:40:00.000-07:00

I wrote an online quoteboard from scratch. Using only my own code makes it lightweight, and I like being able to customize every detail.
After 30 minutes planning and around 30 minutes of quick PHP/Mysql coding, I had a functional version of the site: Each quote also has a page where you can discuss it. Using xmlhttprequest, I added AJAX voting buttons that don't require a page refresh!
Today, I added some styling, which took a while, but looks nicer:

Nondeterministic Finite Automata

2007-11-01T09:18:00.000-07:00

For an open-ended project in my Computer Science course, I wrote a program which will take any regular expression as an input and generate a NFA for recognizing that language. It can display this NFA graphically as well as generate Prolog code for simulating it and using it to match strings. (So, if you have Prolog, you could use this as an implementation of regular expressions.)

I generate dot format files and call GraphViz to draw the graph. I use the symbol ',' to mean concatenation and enter 'a,a,b,b' instead of the traditional regexp 'aabb'. In the graphs, '.' refers to a null transition. Here are some sample inputs and outputs:

a*,b|c (a|b)* (a|b),(a|b) (Note that my handling of * is slightly incorrect because the expression must be present at least once.) Disjunction uses the '|' symbol, for example 'a|b' means a or b. Unlimited levels of nested parenthesis are supported, thanks to recursion.

I process the expression recursively by at each point dividing the input string into two parts, if possible. The string '(a|b),b' is split into (a|b) and b with the operation ',' , and the first part is then split into a and b with the operation |. If the expression is a or a*, then it will return, and work its way down. To my knowledge all complicated expressions are recognized successfully.

The Python program then will output Prolog code that can be consulted. Once consulted, the predicate parse can be used with a list to see if the string is recognized by the language.

Prolog code generated for (a|b),(a|b)

parse(L) :- start(S), 
    trans(S,L).

trans(X,[A|B]) :-
      delta(X,A,Y),
      write(X),
      write('  '),
      write([A|B]),
      nl,
      trans(Y,B).
      
trans(X,[A|B]) :-
      nulltrans(X,Y),
      trans(Y,[A|B]).
      
trans(X,[]):-
    nulltrans(X,Y),
    trans(Y,[]).
      
trans(X,[]) :- 
      final(X),
      write(X),
      write('  '),
      write([]), nl.

delta(0,a,1).
delta(0,b,2).
delta(3,a,4).
delta(3,b,5).
nulltrans(1,3).
nulltrans(2,3).
nulltrans(4,6).
nulltrans(5,6).
nulltrans(99,99).
start(0).
final(6).

Sample output of this Prolog code recognizing (a|b),(a|b):

| ?- parse([a,b]).
0  [a,b]
3  [b]
6  []

true ?

yes
| ?- parse([b,a]).
0  [b,a]
3  [a]
6  []

true ? 

(15 ms) yes
| ?- parse([b,a,b]).
0  [b,a,b]
3  [a,b]

no
| ?- parse([b]).
0  [b]

Audio

2007-10-28T08:26:00.001-07:00

Unlike most of the projects I've been working on, this one was related to a class. (But it is still thrown-together, undocumented, and uses several list comprehensions to write an audio effects in one complicated line of code). I'm in a course called Engineer's Orchestra where we build instruments and do physics. I was curious about how sound files on a computer work , so I set off learning a lot about digital audio. The first fun part was to learn the insides of a .wav file and write one starting from only bytes. Then, as a project for the class, I wrote a complete audio editor from scratch!

I wrote it in Python, because it would take me the least time to write it. My challenge was to write this without referencing any other code, like Audacity. This made it more fun.

The GUI isn't very good, specifically because there are no other dialogs, but I have most of the important features covered: Add Silence Before, Add Silence After, Chop, Append File, Mix File, Modulate, Make Louder, Make Softer. And, it loads and saves standard wav files (16 bit or 8bit), so it is actually practical for editing things you have recorded.

Then, I added a lot of audio effects. I would read the gist of an effect on Wikipedia and try to code it. This was even more fun, because if I got something wrong, it sometimes played very strange sounds. (I don't have any analog-style effects, like filters yet, but this is something I would really like to learn). In the GUI, you can use the following effects: Reverse, Octave up/down, Change pitch (the most challenging to think of how to write), Vibrato, Flanger, Echo, Reverb, Chorus, and Alien Voice. The alien voice modulates the samples with a sine wave - I came up with it while experimenting and don't know why it sounds strange.

Listen to these (the wavs were generated by my program):
Vibrato
Low
Reverb
Alien Voice

Next, I added code to synthesize sounds. Sine, triangle, square, and sawtooth waves aren't that great by themselves, so I tried combinations of them to get the most interesting voices. The secret to making a sine wave sound better is to quietly mix in frequencies at that are slightly different. Surprisingly, the subtle beat frequencies make it sound expressive and musical. I worked a long time to create an electric organ-like instrument out of sine waves, and finally came up with something.

Here are the results:
Electric Organ
Smooth
Retro
Red Noise
Squarephase

Finally, I put all of the pieces together. I had an audio editor that can modify and arbitrarily change the pitches of sounds. So, I made a sampler! I wrote a command-line interface for a program where you can type in notes and play them. It parses commands like a4 into the note A440, or 4.f#5 into "play a dotted quarter note at F# 5". As an instrument, you can use anything - samples of your voice, a sample of a real instrument, your computer's MIDI, or even the same synthesized instruments like Electric Organ or Smooth.

The program works well (the effects even work in both 16bit and 8bit sounds).

Lest you think this program is polished, I must admit that it is not. This is not a joke, it is actually in the source:



manualsynth(audiodata, nsamples, _extend([[freq, .5*0.9**(8-1)]], [[freq*(i+1),.5*0.1*0.9**((8-1)-i)]  for i in range(1,8)],[[freq*1.00606, .5*0.9**(8-1)]], [[freq*1.00606*(i+1),.5*0.1*0.9**((8-1)-i)]  for i in range(1,8)]))

I should get around to fixing that sometime.

Quick Unicode Entry

2007-10-27T15:15:00.000-07:00

This project doesn't have any direct use now, but it was fun to write, and might be useful for writing letters in Spanish. I can simply hit Alt-A to get an a with an accent, Alt-Shift-1 to get ¡, and define any other combination I want.

This program is a lightweight text editor intended for writing text in other languages. Most word processors have a "Insert Symbol" option for inserting a character, but this process is too slow. If you do all of your typing in another language, one can set the system language, but this will be a system-wide change and is not very customizable. In this program, on the other hand, it is simple to set up your own keymaps and choose what keys create which characters. One can also conveniently visualize these bindings.

Because some languages require access to more than 26 symbols, this program uses the concept of "modes." For example, the default keymap has a mode called Grave Accent. In this mode, typing a vowel like o will produce o with a grave accent. The program begins in Normal Mode, but you can press Control+L to enter Grave Accent mode. View the available modes for the current keymap by choosing List Modes from the Characters menu.

When you enter a mode, you stay in that mode until you press the key combination, typically Control+Space, to return to Normal mode.

Edit the current keymap by choosing "Edit key bindings" from the Characters menu. (Changes take place when the mode is selected from the Characters menu). Create a new map by creating a .py.js file in the keymaps directory.

The Code. Unzip and run "main.py." Works in Python 2.5. Linux is not yet supported, as it seems the keycodes are different.

I spent some time coming up with good keymaps. It comes with a map for characters in Latin-1 and a very useful Greek map.

Interesting Facts in Biology

2007-10-24T01:28:00.000-07:00

Did you know?

Slugs are gastropods that have white flowers for a specific tissue.
This has produced a nuclear matrix secreted into the bird’s plasma membrane.
Individuals associate with polar molecules such as that of the worm through the mitochondrial and chloroplast genomes of the urethra.

I wrote a program that will analyze and automatically summarize Biology. (Very useful). It's a web app, but is on Olin's server right now. I compiled a huge amount of Biology information and made a Markov model. I did a lot of work in Python stripping unwanted data. At first, I was putting all of the data in a php file, but this turned out to be inefficient and a heavy load on the server. I ended up with a solution: I divided all of the text into 64 slices, and then created 8 medium-sized files out of shuffled slices (for variety). I then wrote Python code to generate one Markov model for each of the files and save the results as a Javascript object .js file. Then, the php code randomly picks one of the 8 .js files to include whenever the page is loaded. The Markov generation is all client-side, so you can generate many times without needing a page refresh.

Computer Science + Lolcats

2007-10-21T11:57:00.000-07:00

I did some photoshopping last week :)

If you've taken a Computer Science course, you may find this humorous. It's my Powerpoint presentation of Computer Science + Lolcats.

(Feel free to copy these but give me credit).

Beep

2007-10-13T19:22:00.000-07:00

This weekend I thought it would be cool to learn about digital audio. Specifically, I wanted to look inside of audio files and know how they work on the level of bytes. Also, I'm going to do my exploring without looking at other source, like Audacity, to make things more interesting.

It turns out that digital audio files are split up into frames that are typically either 8-bits or 16-bits. So a wave file is essentially list of 8-bit or 16-bit numbers that represent the pressure on the microphone. The frame rate dictates how many of these frames go by per second.

In thirty minutes, I was successfully able to come up with code for creating a .wav file at any frequency:

import wave
import math
import array

#Create a 16 bit wave
width = 2 #16 bits is 2 bytes
maxval = 65535
sample_rate=44100
channels = 1
samples = array.array('h') #Signed short

# Create a sine wav, of frequency fFreq
nSamples = sample_rate*2 #two seconds long
fFreq = 440
w = fFreq*2*math.pi / sample_rate
amplitude = 65535/2 #Loudest amplitude
samples.extend( (amplitude * math.sin(w*x)) for x in xrange(nSamples) )

f = wave.open('c:\\a440.wav', 'wb')
f.setnchannels(channels)
f.setframerate(sample_rate)
f.setsampwidth(width)
f.writeframes(samples.tostring())
f.close()

Some of my ideas: The array type works perfectly for storing the samples - it is far more efficient than a Python list. Note also that I am using a "generator expression", which works similarly to a list comprehension but does not need to actually create the list. In the future I plan on using generators for creating the signals.

It is weird that 16-bit sound is in the "signed short" format, instead of being unsigned.

On a less serious note, I then saw the beep method winsound module, and was amused:

import winsound
# so retro!
winsound.Beep(440,10)
winsound.Beep(600,10)
#bonus stage!
for i in range(40,400,30):
    winsound.Beep(i,90)

There's no way to control the volume, though, so this can get annoying.

Next I'll be writing some sweet audio effects.

Recursive Shapes v0.2

2007-10-11T23:17:00.000-07:00

This project took far longer than half an hour, but it's pretty cool.

While doodling in Bio, I thought of a way to programmatically draw any recursively-defined shape. By this, I mean any shape that contains a scaled-down version of the entire shape. This is a property found in many fractals.

Traditionally, and in all of the fractal-drawing software of this type I've seen, the shapes are defined with turtle-style commands (turn right, draw a line, turn left, and so on). There exists a specific system called L-System that can define recursive pictures, and with a lot of work can probably define everything my program can, with the exception of curves. However, when looking at the shape, I do not always find the long list of turtle instructions or L-System rules to be intuitive. I decided to instead use traditional Euclidean x and y coordinates, and Python code as the rule defining the next iteration. This way, I can sketch out a shape on a piece of paper and enter its code very quickly and clearly. It is much easier to me to enter a shape in terms of x and y.

I had an idea for drawing curved lines that turned out very well. The code actually draws an arc of a circle, but positioned so that the arc passes through the two points. A parameter specifies how much curvature should be given.

Looking at the still images is only half of it: I added an easy way to draw animations! There are a lot of really cool animations defined in the samples. (Play them by removing the # and pressing draw.)

Here is the code (71k). (Requires Python 2.5, cross-platform). All you need to do is unzip the file, open main.py, load a shape from the shapes menu and start playing with it! The argument to the .draw() method is the number of iterations (don't make this too big). You are encouraged to tweak the code or create your own shapes.
I wrote this just for fun, and it's (unfortunately) not connected with anything I'm doing at school.
Planned for the next version:
Drawing images, ellipses, text. Save images as PNG files, anti-alias option. Making variable names consistent... and a revolutionary improvement that is still in the works.

So Good It's Bad!

2007-10-07T14:00:00.000-07:00

I was playing Windows Entertainment Pack Tetris. After the 10th level, it doesn't get any faster (of course it is fast enough) - and so I was playing for a while, when suddenly I noticed that I had a negative score!!! The integer representing my score had overflowed! The Windows Entertainment Pack version of Tetris must display your score as a signed 16-bit integer (I think it's even a 16 bit program). Because of 2s complement, an integer will after being large positive will be large negative. The number still sorted as larger than the other scores, and counted as a high score, though. Cool.

Unreadable Python

2007-10-03T16:22:00.000-07:00


exec(")))'YLRJHOUVO[`WYLO[VUH',dro(pam,)52+c(rhc:c adbmal(pam,__dda__.rts(ecuder tnirp"[::-1])

Actually, I could have made it a lot worse. But it was still fun. Figured it out? Try this one:


print reduce(str.__add__,map(lambda c:chr(c+25),[(72-sum([ord(c)-74 for c in '=IEVM=LAOVCKPQHBP='][:i])) for i in range(19)]))

Periodic Generator

2007-09-28T23:02:00.000-07:00

A few years ago, I saw a t-shirt that spelled "WWU Chemistry" in the style of a periodic table. So, I decided to throw together a DHTML program to spell an arbitrary phrase this way. Today, I cleaned up the code a bit and added sample phrases. The algorithm prefers two-letter combinations to one letter. Unfortunately, a lot of common letters can't be done exactly, so I had to be a bit creative. Here's the link. Unfortunately, to flip letters I have to use a Filter that only works in Internet Explorer; there's no way to do this in Firefox.

Enjoy!

JavaScript and Logic

2007-09-24T15:14:00.000-07:00

Two years ago, I was in a logic course at WWU. The class was interesting, but some of the assigned online work was a bit repetitive. I did enjoy proving theorems, but filling out the truth tables was not exciting.

So, after some thinking, I quickly wrote a script called "logic.js" which can evaluate prepositional logic. I thought of how to do this from scratch (looking back on it there are probably better ways to do evaluate infix notation). For compound expressions, the idea was to use regex to find the innermost operation and evaluate it, replacing it with the result. Then this process would be repeated until there was only one value.

I used the engine to Draw Truth Tables and Evaluate Logic.

For fun, I wrote a similar program for a ProbStat course, at around the same time, for Set Diagrams. None of these are "finished" finished, but they work well enough.

C# Is Useful

2007-09-24T00:09:00.000-07:00

For throwing together a GUI app, C#.NET is actually pretty handy. Here is my demo proving that C# isn't all bad - that is pretty quick and effective. Note that you don't need to use the visual designer at all, and that is what I would do for a larger scale project.
For larger scale projects, XAML is pretty interesting too. I used it at work this summer.
Why I like it:

Compilation step isn't a hindrance - it is fast and catches many mistakes.
GUI designer is helpful but it's easy to code your own layout.
.NET library comes with a lot.
Sweet language features make it feel more flexible and fun than Java.

On the other hand, here are the reasons why I still believe .NET is not the answer:

Not really portable to Linux. (Yes, Mono, but still).
Requires a huge framework. There isn't a way to "static link" your programs. This means that Joe User might have to download lots of megabytes to even run your program, which I know I would be reluctant to do. And what if he is on dial-up?
Memory management and performance - it's pretty good, but watch out for certain things (GC, deep inheritance, reflection, and UI drawing). It is sometimes hard for me to accept that: "My C# program looks and behaves the same as one written in C++. But it is slower and takes more memory." The only answer is developer time. Of course, I am glad that there are simpler languages like C#, and they have benefited me, but this tradeoff is probably partially responsible for today's software bloat.

Tetris

2007-09-20T21:18:00.000-07:00

Bored? Time for Tetris. 1990 Style.
High Score: 25,613 (good)
Favorite Move: The Spear (See it)
Windows Entertainment Pack Tetris is where it's at.

Audacity, and Phonemes

2007-09-19T22:55:00.000-07:00

A friend, Chris, discovered that some songs sound pretty interesting backwards. You can easily open up an mp3 in Audacity and use the "Reverse" effect to try it out.

Good ones:
Hot Butter - Popcorn (0.28Mb)
The Postal Service - The District Sleeps Alone (0.56Mb)
Stryper - To Hell With the Devil (0.49Mb)
Queen - Another One Bites the Dust (0.49Mb)

By the way, the Postal Service and Sinatra go together kind of nicely when you mash them together with Audacity. And of course, Audacity has the wah-wah effect which is good for just about everything.

Also, this summer, I was using a mic to record my voice to get the formant frequencies of my vowels, in order to synthesize my speech. My brother Tim thought of a fun game to play instead:

1) Using Audacity, record yourself saying a simple phrase.
2) Reverse the recorded sound and listen to the weird noises.
3) Record yourself try to make those same noises.
4) Reverse that recording and see if you can understand it!
(Repeat)

It helps to say the phrase very slowly and precisely. We tried to say "Fisher brothers", but it kept on coming out as "Fee-sher Brogleez" :)

The game is challenging because our ears behave strangely when interpreting language, especially vowel sounds. For example, in English many vowel sounds are dipthongs, but mentally we hear them as one unit. I was thinking about this in the car one day. Say the word "high." That is one vowel, right? Wrong. You are actually saying "Ha - eeee" quickly. Same for the sound in "day". That is "deh - eeee". Is that not the weirdest thing? Think about it.

TweakUI, RTF

2007-09-19T21:05:00.000-07:00

I used to Regedit most of my Windows customizations. But now, the TweakIU program provides a GUI for many common changes. Here are some of my favorites:
Read the "tips." There will be some handy keyboard shortcuts. (Did you know you can hold down Control to select many taskbar items? Also, when confirming file actions, Shift+No will mean "No to All."
Under Internet Explorer, you can set the loading-page animation, which I used to great effect. (When I use IE, now I have a running Mario icon when a page loads). I also changed a registry setting so that "Internet Explorer, brought to you by Mario" is in the title of each window.
Finally, under Templates you can edit the entries in the Windows "New file" menu. (This is under the file extension in HKEY_CLASSES_ROOT). I added a "Rich Text Document RTF" entry by pointing to a new .rtf file on my hard drive. Wordpad can be a good lightweight editor if you want simple formatted text. (And, you can use Paste Special/Unformatted to strip formatting). So I always associate .rtf files with Wordpad.
No, rtfm is not a manual in rtf format. It means something else.

Pointillism

2007-09-08T20:29:00.000-07:00

Facebook has a "Graffiti" application where you can draw pictures on a profile by clicking and dragging. Because art is not my forte, I decided to find a way to paste an actual bitmap image in the space.

First, I made a grayscale image of my face. I wrote a little Python script using the Python Imaging Library to make a list of all pixel coordinates that were white. I then wrote an AutoIt script to simulate mouse-clicks at all of those screen locations (hacktastic).

The results:
Not perfect, but still visible.
AutoIt is a pretty cool program for Windows automation. It can simulate keyboard and mouse events.

The actual reason I did this is that I wanted to learn about image processing in Python. It's usually not trivial in most languages / libraries to get pixel access of a PNG image, but PIL seems to do well. Stay tuned for my upcoming ultimate Image Processing lab.

Lame

2007-08-28T02:32:00.001-07:00

Not a hack, but when encoding MP3s I've found it's useful to dispense with some GUI and use LAME direcly. Download the LAME mp3 encoder someplace, and it will come with an executable. Then, you can write a batch file (.bat) like:


rem Adapted from a script by Robert Hegemann
@echo off
:processArgs
if %1=="" goto endmark

"C:\path\to\lame.exe" -h --abr 160 --mp3input %1
if errorlevel 1 goto errormark
shift
goto processArgs
:errormark
echo ERROR processing %1
pause
:endmark
pause

Put the batch file someplace accessible. To encode some songs, all you need to do is drag and drop them onto the batch file.

A n00b's RGB song

2007-08-24T10:28:00.000-07:00

Written at around 3 am:
(Sung to the tune of "abc"/Twinkle Twinkle Little Star)

"0 1 2 3 4 5 6
7 8 9 A B-C-D-E-F
Sharp o o o o o Black
Red Green Blue White Web Safe hack
Now I know my RGBs
I can be a hacker please?"

Speed Reading

2007-08-21T23:28:00.000-07:00

Sometime this year, I was discussing speed-reading with some friends at Olin. We were thinking of faster ways to read. I can't remember exactly why, but that night I wrote this very quickly.

Speed read

Change the number to change the delay between words. (I think the idea is to start at a comfortable level and gradually get faster).

I found it today and quickly renamed some of the variables and made it more browser compatible. (Also, in the old version the loop function would call setTimeout on itself with a parameter, but now I realized that it is better to use a global variable, g_nIndex). This is still definitely a thirty minute hack (low quality, questionable usefulness, and really fun).

Python Ostream

2007-08-21T23:04:00.000-07:00

Here's a hack I read about in the Python Cookbook. This one's for everyone who dislikes C++ :) The idea is to allow syntax like "cout << x" in Python. I liked the idea so I put together a simpler and cleaner implementation.

This is Python code (!):

cout << "hello, world" << nl
cout << "Tuples:" << (5 , 6, 7) << nl
cout << "Lists:" << [5 , 6, 7] << nl
    
cout << "The number, " << 1+1 << ", bigger than " << 1.0/5.0 << nl
print "The number, %s, bigger than %s" % (1+1, 1.0/5.0)
print "The number," , 1+1 , ", bigger than" , 1.0/5.0
# The 2nd is inelegant in my opinion.
# I currently use the 3rd, but note that it inserts spaces, so it prints something different.

and here is the class (concise, and you can even pass it another stream object):

import sys
class OStream():
  def __init__(self, output=None):
    if output is None: output = sys.stdout
    self.output = output
  def __lshift__(self, obj):
    self.output.write(str(obj))
    return self
cout = OStream()
nl = '\n'

The recipe given in the Cookbook was longer, less clean (endl was an IoModifier object rather than '\n'), and used '%s' % obj instead of str(obj). I prefer my approach. I'm sure you could add all sorts of other "useful" features.

Have you ever thought it is weird that left-shift means print? Actually, cout << "hello" is a lot nicer to type than cout("hello"), to me at least, so I don't really mind. Coming up next: subclassing list so that mylist << 4 does mylist.append(4) ... and mylist >> 0 does mylist.pop(0). (Just kidding).

Change Desktop Pattern

2007-08-10T13:07:00.000-07:00

Here's another example of how you can make something really nifty in under thirty minutes. A year ago, I wrote a WSH script to change my desktop pattern on startup. I found the right registry keys to change, but unfortunately, the changes wouldn't take effect until the desktop was refreshed. Then, I found an example of how to refresh the desktop here (I guess someone else had thought of this before me), and so I was ready. Note: I haven't tested this in Vista.
To set it up,
1) Create a folder, and a subfolder named "bgtemp".

2) Enter the following and save it as "go.bat", within the folder:

echo "Change of Wallpaper - Ben Fisher"
@echo off
del bgtemp\*.bmp
cscript /NoLogo changed.wsf

3) Enter the following and save as "changed.wsf". Change the code so that strPath is set to any directory with JPG pictures, and strDestination is set to the "bgtemp" directory.

<job id="ChangeBG">
<script language="JScript">
fs = new ActiveXObject("Scripting.FileSystemObject");
var fso, e, file;
var strName; 
var aNames = [];
var strPath = "C:\\Program Files\\Ben's Fractal Screensaver\\Media";
var strDestination = "C:\\Program Files\\Ben's Fractal Screensaver\\Script\\bgtemp\\";
fso = new ActiveXObject("Scripting.FileSystemObject");
e = new Enumerator(fso.GetFolder(strPath).files);
for (e.moveFirst(); ! e.atEnd(); e.moveNext()) 
{
  file = e.item();
  strName = file.name.toString();
  if (strName.indexOf(".jpg") > 1) 
    aNames.push(strName);
}
var nWhich = Math.floor(Math.random() * aNames.length);
var fullpath = strPath + '\\' + aNames[nWhich];
strDestination += aNames[nWhich] + '.bmp';

//Convert to bitmap
var Converter = WScript.CreateObject("Gfx.Converter");
Converter.ToBitmap( fullpath, strDestination );

// Change registry
var objShell = WScript.CreateObject("Wscript.Shell");
objShell.RegWrite("HKEY_CURRENT_USER\\Software\\Microsoft\\Internet Explorer\\Desktop\\General\\BackUpWallpaper", strDestination);
objShell.RegWrite("HKEY_CURRENT_USER\\Control Panel\\Desktop\\Wallpaper",  strDestination);
objShell.RegWrite("HKEY_CURRENT_USER\\Control Panel\\Desktop\\Wallpaper",  strDestination);

// Refresh, credit to http://www.oreilly.com/pub/h/5091
objShell.Run("%windir%\\System32\\RUNDLL32.EXE user32.dll,UpdatePerUserSystemParameters", 1, false);
</script>
</job>

4) You'll also need the "convert to bitmap" ActiveX control from http://dev.remotenetworktechnology.com/wsh/comwsh.htm. Unzip and register the dll with the command: Regsvr32 GfxConverter.ocx. It is kind of interesting to learn that desktop patterns must be .bmp files - if you choose another file type in the Desktop control panel it is silently converted into bmp.

5) Put a shortcut to "go.bat" in your startup folder. c:\Documents and Settings\(you)\Start Menu\Programs\Startup.
And that's it!

System Sounds!

2007-08-10T12:19:00.000-07:00

Here's a great way to make your operating system more fun. First, get little clips from some of your favorite songs - the more distinctive, the better. Audacity is perfect for this. You'll have to export into WAV format, then, in the control panel, set them as your system sounds.
My computer is now Incredibly Awesome!

Start Windows	Gloria
Windows Logon	Berg - Violin Concerto Mv. III Allegro
Exit Windows	Grandmaster Flash - The Message
Windows Logoff	Edgar Winter - Frankenstein
Device Connect	Javanese Bell Excerpt
Device Disconnect	Javanese Bell Excerpt
Program Error	James Brown - Living in America
Critical Stop	Yes - City of Love
Asterisk	John Cage - Sonatas and Interludes for Prepared Piano
Default Beep	Lou Harrison - Concerto for Flute and Percussion Movement II
System Notification	Lou Harrison - Concerto for Flute and Percussion Movement II
Exclamation	Toru Takemitsu - November Steps for Orchestra

I pulled these 2-second clips from songs in my music library, and I also got some good clips from an old copy of Encarta (I love the bells). Because the volumes aren't normalized, things are even more exciting. Feel free to use these!

Chat History Reader

2007-08-10T12:00:00.001-07:00

I used Windows Live Messenger quite a bit at work this summer. You can save message logs in an xml format (enable this in Options). There is an xslt to view the logs in IE, but I wanted something cleaner.
So, I put together a quick app in Windows Forms. (You'll need the .NET 2.0 framework). It doesn't do much, but it does have search. The main interest for me was to use the XmlTextReader (a very nice lightweight xml reader built in to .NET, perfect for this task). I was also interested in RTF; instead of the methods for formatting, I set the raw RTF of the RichTextBox. The result is a useful little app, thanks to .NET.
Source and binary (68 k).

Visual Studio Shortcuts

2007-08-10T09:45:00.000-07:00

Visual Studio Shortcuts Here are some of the Visual Studio shortcuts I use.

Commands

Visual Studio includes a basic command-line prompt that is very useful for opening files. One way to enter commands is to press control+/, and then type >. You can then start typing a command, like "open", and then part of a filename. The nice part is that this autocompletes, so this is a great way to open any file in your solution quickly. Press enter and the command is run. All of the commands you see in Tools-Options-Keyboard can be entered too, such as "File.CloseSolution" and so on.
There is a "command window" that is dedicated to this. I've mapped Ctrl+Space to View.CommandWindow, which is quicker than Ctrl+/, >. You can set up an alias to any command. For example, to set up an alias to a commonly used file, enter this:

alias m File.OpenFile CommonlyUsedFile.cs

Now, you can press Ctrl+Space,m,Enter to quickly open that file - very useful if you have a large solution. There are many built-in aliases such as "open" for "File.OpenFile". View this list by typing "alias" with no parameters, or remove an alias with the syntax "alias m /delete". I deleted most of the other aliases, as I'd rather type Ctrl+F4 then "close", and so on.
Useful aliases:

sh Tools.Shell
o File.OpenFile
cls Edit.ClearAll
g Debug.Start
bl Debug.Breakpoints
kb Debug.ListCallStack

Macros

Macros are a great idea, but I'm not too impressed with them in VS. VB is such an ugly language, and there is a distracting pause when running a macro. Anyways, I'd thought I'd try my hand. Here's something that will complete all nested parens and end the line. For example, if you type Console.WriteLine(a.ToString( and run the macro, it will add "));" and start the next line. I've mapped this to Control+Enter, and it can be useful if you are too lazy to count how many parens to close.

Sub CompleteLine()
Dim line As String
DTE.ActiveDocument.Selection.StartOfLine(0)
DTE.ActiveDocument.Selection.EndOfLine(True)
line = DTE.ActiveDocument.Selection.Text

Dim nparens As Integer, i As Long
nparens = 0
For i = 1 To Len(line) - 1 Step 1
    If StrComp("(", Mid$(line, i, 1), vbTextCompare) = 0 Then
  nparens = nparens + 1
    ElseIf StrComp(")", Mid$(line, i, 1), vbTextCompare) = 0 Then
  nparens = nparens - 1
    End If
Next

Dim strResult As String
strResult = ""
For i = 1 To nparens Step 1
    strResult &= ")"
Next
strResult &= ";"

DTE.ActiveDocument.Selection.EndOfLine()
DTE.ActiveDocument.Selection.Text = strResult.ToString()
DTE.ActiveDocument.Selection.NewLine()
End Sub

I also have a macro that duplicates the current line, but I'm frustrated by the pause. My wish is to come up with something that could organize my Ctrl-Tab into visual, and not MRU order, but that's a story for another day.

Snippits

Snippits are a great feature of VS 2005. You can easily create your own snippits by creating xml files. There is a nice GUI for creating Snippits called Snippy (A Visual Studio 2005 PowerToy), but it seems to have dissapeared entirely along with gotdotnet.com. So, I've posted it here (378k).
I wrote snippits for creating unit tests, switch statements, and some XAML structures. Most often I used prop and propd for quickly creating properties.

Shortcuts

Finally, here are some keyboard bindings that I find useful:

Ctrl+Space	View.CommandWindow
Ctrl+Q	Edit.CommentSelection
Ctrl+Shift+Q	Edit.UncommentSelection
Ctrl+Alt+,	Toggle Bookmark
Ctrl+,	Next Bookmark
Ctrl+Shift+,	Prev Bookmark
Ctrl+Alt+W	Watch Window
Ctrl+Alt+K	Call stack
Ctrl+Alt+R	Toggle Word wrap
Ctrl+Shift+Alt+W	File.CloseSolution

If you happen to have MbUnit (which is cool) or VisualSVN,

Ctrl+T	MbUnit – Run Tests
Ctrl+Shift+R	VisualSVN-Revert Changes current item
Ctrl+Shift+H	VisualSVN- Show current file changes
Ctrl+Shift+Alt+H	VisualSVN – Show All Changes

Some of these override standard key bindings, but it’s easy to assign another. I have Ctrl+Shift+Space to be Edit.CompleteWord rather than Ctrl+Space. Anyways, those are some ways to make Visual Studio work for you. The Clipboard ring is nice also.

Adding Links to Web Album Generator

2007-08-07T23:21:00.000-07:00

Web Album Generator is a great freeware program for creating online photo albums. It is sleek, easy to use, and does things the right way.
The only complaint I have is that it is not very customizeable. I like how in Facebook albums, clicking on the current photo takes you to the next photo, providing a quick way to skim through the pictures without having to find the "next" link. Web Album Generator has no option for this. But, since the output is just normal HTML, I can write a script to make changes to all of the HTML files.
Here's a Python script that will do the trick. If you haven't used Web Album Generator, you should give it a try. After exporting the album, specify the directory (strDirectory) and run the script. (You might want to make a backup copy first.)

# Designed for Web Album Generator 1.8.2 (ornj.net)
import os
import re

strDirectory = r"C:\outputdirectory"
astrFiles = os.listdir(strDirectory)

reNextPicture = re.compile('<a href="([^"]+.html)" title="Next Photograph">Next')
reEndlink = re.compile('(</div>)\s+(<p class=")')

def main():
  for strFilename in astrFiles:
    if strFilename.endswith("html"):
      f = open(st + '\\' + strFilename, 'r')
      strHtml = f.read() #Read entire file
      f.close()
      
      objmatch = re.search(reNextPicture, strHtml)
      if objmatch:
        filenext = objmatch.group(1)
        strHtml = strHtml.replace('<div id="photograph">', '<div id="photograph"><a href="'+filenext + '">',1)
        strHtml = reEndlink.sub('</a> </div> <p class="',strHtml)

        fout = open(strDirectory + '\\' + strFilename, 'w')
        fout.write(html)
        fout.close()
        print "Written:" + strFilename
main()