I’ve built a Python proof of concept (using md5 as a hash function) suitable for Linux.

import hashlib
import struct
 
 
class GRandom:
    def __init__(self):
        self.audio = open("/dev/dsp","rb")
        self.hash = hashlib.md5()
 
    def get_raw_block(self):
        buffer = self.audio.read(self.hash.block_size*8)
        bytes = struct.unpack("%iB"%len(buffer), buffer)
 
        longs = []
        for i in range(self.hash.block_size/4):
            temp = 0
            for b in bytes[i*32:(i+1)*32]:
                temp = (temp << 1) ^ (b & 1)
            longs.append(temp)
        return struct.pack("%iI"%len(longs), *longs)
 
    def get_block(self):
        self.hash.update(self.get_raw_block())
        return self.hash.digest()

The amount of generated bits per second is given by (sample rate)*(digest size)/(block size). So for 8KHz (default) sampling rate and md5 we’ll get a theoretical speed of ~250Kbs. SHA type hashes have higher digest to block size ration thus may result in higher speeds. Another source of speed up may be to change the sample rate of the microphone. But setting it to high may have negative effects on the entropy. The code may get a considerable performance gain by porting it to c/c++, as it uses both bit manipulations and calculates hashes. Anyways, even the Python implementation’s speed allows us it be used for many cases where true randomness is required, such as generating passwords.

TypeError: character mapping must return integer, None or unicode

This is pretty unhelpful error message also occurs if you try any method that indirectly use altchars. For example:

base64.urlsafe_b64decode(unicode('aass'))
base64.b64decode(unicode('aass'),'-_')

both fail while the following works:

base64.urlsafe_b64decode('aass')
base64.b64decode(unicode('aass'))

While it’s not complicated to fix it (just convert any unicode string to ascii string), it’s still annoying.

The following Python functions allow you to build and read these 6 chars URL-safe timestamps:

import base64
import struct
import time
 
def build_timestamp():
    """
    Return a 6 chars url-safe timestamp
    """
    return base64.urlsafe_b64encode(struct.pack("!L",int(time.time())))[:-2]
 
def read_timestamp(t):
    """
    Convert a 6 chars url-safe timestamp back to time
    """
    return struct.unpack("!L",base64.urlsafe_b64decode(t+"=="))[0]

These functions work by translating the timestamp into a 4-byte binary form and then encoding it using a URL-safe version of Base64. And finally we strip the padding, which is neither URL-safe nor necessary (as we know the size of the encoded data).

The result looks something like this:

In [72]: build_timestamp()
Out[72]: 'S9sNOQ'

We got a timestamp in using only 6 URL-safe chars.

The guidelines weren’t just empty words, they were written while working on the Hebrew adaptation to the Fusion theme and in the same time writing a new proof-of-concept version of cssrtl.py. The original intent was to release a more mature version of that code when it will be completed. However, due to the apparent shortage of time in the present and foreseeable future, I can’t see myself complete the project any time soon. So following the “release early” mantra, I’ve decided to release the code as-is. As I said, the code is in working state, but not polished, so it may be of benefit but may contain bugs. If you find any bugs or have any suggestions, I would be glad to hear.

Download

You can download the new version from here: cssrtl.py-2.0.tar.bz2. The code is available under the GPLv2 or any later version.

Usage

The new version works by creating a seperate css “fix” file that fixes the directionality of the css styles.

./cssrtl.py < main.css > main-rtl.css

Afterward, just link the main-rtl.css after main.css in your HTML files.

My next shot at this was to use imagemagick’s fx operator. It allows you to iterate over the pixels in the image and apply some custom expression. While it sounded very good, it turned out to be a disaster as this thing was very slow. It is so slow, it becomes useless on high-resolution pictures, it didn’t finish operating on the 300dpi scanned document even an hour after it started. In my opinion, it is below par even when operating on relatively small images. This feature would become great if it would only operate faster.

At this point I’ve realized I probably can’t do it directly from the command line, and I decided to implement a solution using Python, and the Python Imaging Library (PIL), this was the start of my new project – biscan (blue ink scan).The program iterates over the pixels in the image and checks the blue level, if the blue level is high (but not too high) if forces the pixel to become black. The following code is still pretty experimental, and is the first prototype.

#!/usr/bin/python
"""
biscan - Blue Ink Scan 0.1. Takes a color image of a scanned document written using
blue ink, and turnes it into a blac-and-white (lineart) image.
(C) 2008 Guy Rutenberg. Released under the terms of the GPLv2.
"""
import sys
import Image
from optparse import OptionParser
 
def parseArguments():
	parser = OptionParser(usage="%prog [options] FILEIN FILEOUT", 
			version="%prog 0.1 ")
	parser.add_option("-v", "--verbose", dest="verbose", action="store_true", default=False,
			help="be verbose")
	parser.add_option("-b", "--blue-threshold", dest="blue_threshold", type="int", default=220,
			help="Set the blue threshold (0..255) to NUM", metavar="NUM")
 
	return parser.parse_args()
def main(options, args):
	if len(args)<2:
		print "See --help for usage instructions"
		return 1
 
	im = Image.open(args[0])
	pix = im.load()
 
	for x in xrange(im.size[0]):
		for y in xrange(im.size[1]):
			if pix[x,y][2]<options.blue_threshold:
				pix[x,y] = (0,0,0)
		if options.verbose: print "proccessed line",x
 
	def threshold(i):
		if i<127: return 0
		return 255
	im.convert("L").point(threshold).save(args[1])
 
if __name__== '__main__':
	(options, args) = parseArguments()
	sys.exit(main(options, args))

See python biscan --help for options. This version outperforms all the above mentioned methods in quallity and the compression ratio achieved on the output. Its performance are reasonable, around 10 sec for 8 mega-pixel image. I’ve tested it with several different blue inks (Uniball, Pilot, Ballograf and some generic ones) and it operated pretty well on all of them.

So what next? I plan to improve the script and allow it to almost perfectly convert documents written in blue ink to B&W. I’m going to experiment with a new model for identifying the blue ink using HSL values (instead of RGB). The next version will also be more polished, as I’ve released this one under the motto of “release early” (and I hope I will also release often). So stay tuned for updates.

If you give this script a try, I will glad to hear about it. Of course if you have any question you’re welcomed to contact me.

N.B. The biscan requires PIL 1.1.6 (the latest one as of this time). PIL can be found in Gentoo under dev-python/imaging.