Coding Mess

Transforming RGB data to wavelength information

2010-02-25T19:13:00.005+01:00

Here, I'm presenting a reverse transformation to wavelength to RGB. Right now I have no means of testing its accuracy on some real data. As a first check, I've run it on the mercury lamp image shown in my older post. There are small deviations caused probably by low intensity of light in some places. If used on some real stuff, I would definitely attempt to first fit a line (or some other meaningful function) through the estimated wavelengths. Then of course plot the spectra against fitted values. The domain of this function is limited to 380 - 645 nm. So, here's the algorithm in Python:


def RGB2lambda(R, G, B):
   """Returns 0 if indeciferable"""
   # selects range by maximum component
   # if max is blue - range is 380 - 489
   # if max is green - range is 490 - 579
   # if max is red - range is 580 - 645
  
   # which colour has highest intensity?
   high = float(R)
   highind = 1
   if G > high:
       high = float(G)
       highind = 2
   if B > high:
       high = float(B)
       highind = 3
      
   # normalize highest to 1.0
   RGBnorm = [R / high, G / high, B / high]
  
   # start decoding
   RGBlambda = 0
   if highind == 1: # red is highest
       if B >= G: # there is more blue than green
           return 0 # max red and more blue than green shouldn't happen
       # wavelength linearly changes from 645 to 580 as green increases
       RGBlambda = 645 - RGBnorm[1] * (645. - 580.)
      
   elif highind == 2: # green is max, range is 510 - 579
       if R > B: # range is 510 - 579
           RGBlambda = 510 + RGBnorm[0] * (580 - 510)
       else: # blue is higher than red, range is 490 - 510
           RGBlambda = 510 - RGBnorm[2] * (510 - 490)
          
   elif highind == 3: # blue is max, range is 380 - 490
       if G > R: # range is 440 - 490
           RGBlambda = RGBnorm[1] * (490 - 440) + 440
       else: # there is more red than green, range is 380 - 440
           RGBlambda = 440 - RGBnorm[0] * (440 - 380)
  
   return RGBlambda

And here is an accuracy check made on my older image of mercury lamp spectrum:

Accuracy check (synthetic test): x-axis is expected value, y-axis is algorithm output. Circles are the data, the ideal is presented by red line (y = x).

Please note that this was NOT produced by using a real photo of a spectrum. As someone who has some spectroscopic background I strongly discourage you from using this algorithm to get wavelength information. This was derived from a simplified version of simple wavelength-to-RGB algorithm. Nevertheless, I intend to make some photos of monochromatic light and test it ;-)

How to make a .wav file with Python, revisited

2010-02-21T17:04:00.003+01:00

I've noticed that my two-year old post about making a .wav file with Python is being read a lot so I forced myself to modify the code a little. Now it should be nicer to read and modify further according to your needs/wishes. I've also incorporated the comments of helpful readers Mike Axiak and Fingon. Thanks guys ;-)
The link to the source of this idea, code by Andrea Valle, does not work as I'm typing this so I can only thank him by saying his name. My contribution to all this is minor.


import numpy as N
import wave

def get_signal_data(frequency=440, duration=1, volume=32768, samplerate=44100):
    """Outputs a numpy array of intensities"""
    samples = duration * samplerate
    period = samplerate / float(frequency)
    omega = N.pi * 2 / period
    t = N.arange(samples, dtype=N.float)
    y = volume * N.sin(t * omega)
    return y

def numpy2string(y):
    """Expects a numpy vector of numbers, outputs a string"""
    signal = "".join((wave.struct.pack('h', item) for item in y))
    # this formats data for wave library, 'h' means data are formatted
    # as short ints
    return signal

class SoundFile:
    def  __init__(self, signal, filename, duration=1, samplerate=44100):
        self.file = wave.open(filename, 'wb')
        self.signal = signal
        self.sr = samplerate
        self.duration = duration
  
    def write(self):
        self.file.setparams((1, 2, self.sr, self.sr*self.duration, 'NONE', 'noncompressed'))
        # setparams takes a tuple of:
        # nchannels, sampwidth, framerate, nframes, comptype, compname
        self.file.writeframes(self.signal)
        self.file.close()

if __name__ == '__main__':
    duration = 2
    myfilename = 'test.wav'
    data = get_signal_data(440, duration)
    signal = numpy2string(data)
    f = SoundFile(signal, myfilename, duration)
    f.write()
    print 'file written'

Conversion of wavelength in nanometers to RGB in Python

2009-05-22T19:28:00.022+02:00

I've been recently doing some calibration/benchmark/demonstration measurements of spectra on an instrument I'm building and thought that it would be cool to visualize the spectra so that you could actually see them in colour. I've also never been able to memorize what colour which wavelength was, so this could even be a self-education project. In other words, the task was to transform wavelength data in nanometers into RGB data.

A short Google search turned up some very informative sites and among them was the algorithm for nanometer to RGB conversion. What seems to be the oldest search result is a conversion algorithm written by Dan Bruton in FORTRAN. You may also be interested in the Color Science site from the same author. As I was a bit confused by the FORTRAN code, I also used what appears to be a translation of this code into C#. I know C# about as much as FORTRAN but the syntax was more understandable to me. My only contribution was a literal translation of the algorithm into Python.

The function takes a value in nanometers and returns a list of [R, G, B] values. Although a PIL putpixel function requires a tuple, I found a list more flexible in case you want to change the values e.g. according to measured intensity. So, here is the code:


def wav2RGB(wavelength):
    w = int(wavelength)

    # colour
    if w >= 380 and w < 440:
        R = -(w - 440.) / (440. - 350.)
        G = 0.0
        B = 1.0
    elif w >= 440 and w < 490:
        R = 0.0
        G = (w - 440.) / (490. - 440.)
        B = 1.0
    elif w >= 490 and w < 510:
        R = 0.0
        G = 1.0
        B = -(w - 510.) / (510. - 490.)
    elif w >= 510 and w < 580:
        R = (w - 510.) / (580. - 510.)
        G = 1.0
        B = 0.0
    elif w >= 580 and w < 645:
        R = 1.0
        G = -(w - 645.) / (645. - 580.)
        B = 0.0
    elif w >= 645 and w <= 780:
        R = 1.0
        G = 0.0
        B = 0.0
    else:
        R = 0.0
        G = 0.0
        B = 0.0

    # intensity correction
    if w >= 380 and w < 420:
        SSS = 0.3 + 0.7*(w - 350) / (420 - 350)
    elif w >= 420 and w <= 700:
        SSS = 1.0
    elif w > 700 and w <= 780:
        SSS = 0.3 + 0.7*(780 - w) / (780 - 700)
    else:
        SSS = 0.0
    SSS *= 255

    return [int(SSS*R), int(SSS*G), int(SSS*B)]

The output value's range is 0 -- 255. The code could use some streamlining, but even in this form it is fast enough for an occasional image.

Here is whole visible spectrum as made by this function:

... and a line spectrum of our decades-old mercury vapour lamp:

Finally, in case you want to read more about computer colour science:
Rendering spectra
Colour Rendering of Spectra

Creating NumPy arrays in Pyrex

2008-12-02T14:03:00.005+01:00

In a previous post I have described basic usage of the Pyrex language which may be used to interface C code into Python or to speed up your Python code by adding C-like declarations. At the time I did not knew how to use numpy C-API to create new numpy arrays. I have mentioned it in the post and luckily for me a very helpful comment by diffusing thoughts showed me how to do this. It also got me started so that I could decipher how to use other C-API calls.
I currently do not have any production code in which the array creation is a bottleneck. Nevertheless I was curious if these C-API calls are actually faster than using the Python calls to NumPy. Here I present a howto describing what I learned together with some benchmarking results. I'm certain that I will forget how to use these C-API calls and hopefully this post will one day save me some time.

Prerequisites

numpy and pyrex have to be installed

c_numpy.pxd file from the numpy installation must be accessible (I just put it into my current working directory)

I use the following header of the pyrex (*.pyx) file:

import numpy
cimport c_numpy
cdef extern from "C:\Python25\Lib\site-packages\numpy\core\include\numpy\arrayobject.h":
    cdef object PyArray_SimpleNewFromData(int nd,
                                          c_numpy.npy_intp *dims,
                                          int typenum,
                                          void *data)
    cdef object PyArray_ZEROS(int nd,
                              c_numpy.npy_intp *dims,
                              int typenum,
                              int fortran)
    cdef object PyArray_SimpleNew(int nd,
                                  c_numpy.npy_intp *dims,
                                  int typenum)
    cdef object PyArray_Arange(double start,
                               double stop,
                               double step,
                               int typenum)

c_numpy.import_array()

The documentation for C-API of numpy is available for download on the numpy homepage in the form of "Guide to NumPy" pdf file (numpybook).

numpy.zeros vs. PyArray_ZEROS

example:

cdef int length
cdef c_numpy.ndarray newarr
length = 10
newarr = PyArray_ZEROS(1, &length, c_numpy.NPY_DOUBLE, 0)

notes:

for multidimensional arrays the first two variables within PyArray_ZEROS have to be changed accordingly, see numpybook (I have not tested this)

the type may also be changed if desirable (I however only need doubles)

equivalent numpy code:

newarr = numpy.zeros(length)

Benchmarking these two ways shows that they have the same speed for creating arrays larger than ~ 100 000 values. The C-API is faster on arrays smaller than ~ 50 000 values and about 50% faster on arrays of length 1 000.

numpy.arange vs. PyArray_Arange

example:

cdef double start, stop, step
cdef c_numpy.ndarray newarr
start = 0
stop = 10
step = 1
newarr = PyArray_Arange(start, stop, step, c_numpy.NPY_DOUBLE)

equivalent numpy code:

newarr = numpy.arange(start, stop, step)

Here the C-API is only faster on small arrays (length less than 1 000).

numpy.empty vs. PyArray_SimpleNew

example:

cdef int length
cdef c_numpy.ndarray newarr
length = 10
newarr = PyArray_SimpleNew(1, &length, c_numpy.NPY_DOUBLE)

equivalent numpy code:

newarr = numpy.empty(length)

This is the only case where using C-API is always faster than the numpy way. PyArray_SimpleNew is about 65% faster on arrays of length less than 50 000. It is ~20% faster on arrays of length 500 000. It is still somewhat faster in creating arrays of length 50 000 000.

PyArray_SimpleNewFromData
This call creates a new numpy array from malloc-ed C array.

example:

cdef extern from "stdlib.h":
    ctypedef int size_t
    void *malloc(size_t)

cdef c_numpy.npy_intp size
cdef c_numpy.ndarray newarr
cdef double *arrsource

size = 10
arrsource = <double *>malloc(sizeof(double) * size)
newarr = PyArray_SimpleNewFromData(1, &size, c_numpy.NPY_DOUBLE, <void *>arrsource)
newarr.flags = newarr.flags|(c_numpy.NPY_OWNDATA) # sets the ownership bit

Notes

I have seen some discussion posts which discourage from doing this. See e.g. here.

It may also be helpful to read this post by Travis Oliphant

Technical notes
The benchmarking was done by repeated allocation of a lot of arrays from within Pyrex code. The length of the arrays was also varied to assess whether there is some dependency on the amount of memory being allocated. The largest arrays tested were the largest which didn't caused MemoryError in Python. The number of allocations was selected to assure that the benchmark run at least several seconds (generally thousands of calls or more). I have also tested that it is safe to read and write values into the created arrays.
The benchmarking was done on a PC with Windows XP, Python 2.5.2, Pyrex 0.9.8.2, MinGW 5.1.4 and NumPy 1.2.0.

Pyrex for dummies

2008-11-24T19:15:00.025+01:00

Pyrex is a very powerful tool if you need to speed up some Python code or connect it with some C code. My main motivation to use it was the ability to distribute only the compiled files and not also a C compiler etc.

Unfortunately, the learning curve is a bit steep if you want to do anything non-trivial (if you are not a skilled programmer, that is). I find it very difficult to read and understand just about anything about Python C API and related topics. So any attempt to learn new tricks means spending hours with Google and trying to find an example of usage which is simple enough for me to understand.

What follows is a few steps which I generally follow when rewriting Python into Pyrex code.

Profile your code. Start with rewriting the slowest parts of your code (unless you want to know how fast you can make everything).

Try to compile unchanged Python code with Pyrex. This way you will start with a working code and if something goes wrong you probably broke it with later changes.

Declare loop control variables as C types:
```
cdef int i
```
and change Python for loops into Pyrex for loops
```
for i from 0 <= i < 10:
```

Numpy array data should be accessed directly. It's fairly easy to do now, that I finally know how to do this (see further).

Additional speedup may be achieved by eliminating or minimising Python function calls and/or replacing them with C function calls.

To help understanding your functions, add at least one line to the docstring such as:
```
"""myfunc( N, array x) -> array y"""
```
Pyrex (or C) function parameters are not accessible as in Python functions by using help(myfunc) therefore you must explicitly write it to the docstring.

These steps have so far done the trick for my purposes. I essentially only need fast maths code so I have no idea about other areas. What I may have to learn later is some string stuff but so far I had neither guts nor reason to try it. This means I'm using pure Python strings in my Pyrex modules.

Now some selected details as promised:
To use some standard C function you have to declare it before use. So, if I e.g. need asin() from the math.h library I put this at the beginning of the Pyrex module:

cdef extern from "math.h":
   double asin(double)

Using Numpy C API to access array data directly was tough to learn, this is my current way:

put to the beginning of the script:
```
cimport c_numpy
```
for this to work you have to copy 'c_numpy.pxd' file from 'Python\Lib\site-packages\numpy\doc\pyrex' into the directory with your script (there is a warning about future removal, I hope the same-named file in '\doc\cython' will work as well).

initialize numpy by :
```
c_numpy.import_array()
```

declare new numpy array:
```
cdef c_numpy.ndarray x
```

create numpy array:
```
x = numpy.zeros(10)
```
There is another (possibly faster) way of creating new arrays but this is what i use now (I also do not know the other way, should have made a note...).

declare pointer to store the adress of the numpy array data:
```
cdef double *xdata
```

copy data adress to your pointer:
```
xdata = <double *>x.data
```
The x.data is a char poiter to the first number in your array. I have no idea what this means (why char?).

you may now index xdata to get desired element value:
```
xdata[6] = 12.54
```
or
```
tempvar = xdata[1]
```

you may declare the numpy array in the same way during function declaration:
```
def myfunc(double step, c_numpy.ndarray x):
...
```

Using the Numpy C API is more cumbersome than just indexing numpy arrays but the code speedup is often significant.
Looking through my Pyrex modules this should in essence be all that is needed to get started with Pyrex.

Pyrex - mixing C and Python code

2008-11-21T11:16:00.009+01:00

I have had a little optimization mania recently. After realizing that scipy.weave is ill suited for deployment on the computers of my non-programming colleagues I was looking for other options and tried the Pyrex extension. I recommend reading the Pyrex home page for details of what exactly Pyrex is. A title sentence of its home page explains it nicely:

Pyrex lets you write code that mixes Python and C data types any way you want, and compiles it into a C extension for Python.

This has the (for me) significant advantage that there is no need to install scipy and gcc on any computer that you want your code to run on (as compared to the scipy.weave model). Distributing the compiled extension file is enough.
To make Pyrex work on Windows follow these instructions (here seems to be a copy). As usual you have to change something a bit to make it work with gcc. The key step of these instructions is creation (or edit) of distutils.cfg and adding these lines into it:

[build]
compiler = mingw32

Aside from this I also use a modified python setup command:

python setup.py build-ext --inplace

It suits me better to have the compiled extension in the working directory and not in Python dir as happens with the 'install' command.
I am aware of the Cython language which has developed from Pyrex but I have not tried it. I guess I don't need to fix what ain't broken ;-) Pyrex works great for me right now.

Speeding up Python code with Psyco

2008-08-26T17:14:00.008+02:00

Possibly the easiest way of speeding up Python code is to use Psyco. Psyco is extremely easy to use and it is at least worth a try before delving into C/C++ mess either directly or with the help of scipy.weave.
The usage is simple, just download Psyco, install it and add following to your code:

import psyco
psyco.full()

The full() directive tells Psyco to optimize everything. I usually put these two lines to the beginning of the code, just after other imports. Psyco website states that possible speedups can be between 2x-100x. I have seen every number between 10% faster to 50x faster code execution.
The following is an example of very high acceleration of very simple code:

def test(N, M):
    res = []
    for i in range(N):
        for j in range(M):
            if j == 0:
                x = i*i*i
                res.append(x)
    return res

Running this function with N = 10000 and M = 100000 takes ~60 seconds on Intel E8200 processor. After importing and running Psyco the very same code takes ~1.2 seconds. The speedup is then ~50x.
Psyco works best on functions which run at least couple of seconds per each call and are similar to the presented test function. Psyco only optimizes code within functions and ~~scripts~~ classes but this isn't really a problem.
To only optimize one function use

psyco.bind(yourfunctionname)

Improving blogger template style - Sand Dollar

2008-08-23T16:19:00.004+02:00

There is something what I don't like on my currently selected blogger template style - the Sand Dollar. It spans all available screen real estate from left to right. I would like to make it fixed-width and centered. To achieve this, I've changed the '#outer-wrapper' part of the template by adding 'width: 980px;'. This makes the rendered web page stay only 980 pixels wide which should be enough even on 1024 pixel wide common displays.
To center web page contents, just add 'margin: 0 auto;' to the same section. This means in english: top and bottom margins are zero, left and right margins are set by browser (which means content will be centered). You can find the specifications of the margin command here.
The entire outer-wrapper section now looks like this:


#outer-wrapper {
font:$bodyfont;
width: 980px;
margin: 0 auto;
}

scipy.weave doesn't work - compiler troubles

2008-08-21T18:39:00.011+02:00

The scientific python package SciPy contains a very powerful library called weave. Weave enables one to relatively easily embed C/C++ code into Python code. Thus, if you happen to have a computationally intensive code you can gain a lot of speed by rewriting it in C/C++. There are a lot of ways of how to accomplish this but weave makes this feat relatively easy even for an amateur like me.
There is however one caveate for Windows users. I commonly install all software into the 'C:\Program files\' directory. If you do this with Python and a weave requirement, MinGW compiler, weave will not work. The trouble is the space within directory name. Weave scripts and possibly also gcc are not written to deal with spaces within paths and will not find required files like gcc.exe. You will end up with error messages like:

error: command 'gcc' failed: No such file or directory
ValueError: The 'mingw32' compiler was not found.

At first I have made a hack in the first affected script, the 'platform_info.py', but this only resulted in another error:

Could not locate executable g++
Executable g++ does not exist
Traceback (most recent call last):
 File "G:\Temp\tmpfgm8bn\_ev-uq.py", line 8, in 
   s,o = exec_command(cmd, _with_python=0, **{})
 File "C:\Program Files\Python25\lib\site-packages\numpy\distutils\exec_command.py", line 253, in exec_command
   use_tee=use_tee,**env)
 File "C:\Program Files\Python25\lib\site-packages\numpy\distutils\exec_command.py", line 402, in _exec_command
   so_dup = os.dup(so_fileno)
OSError: [Errno 9] Bad file descriptor

So, to make things short, just install Python and MinGW into C:\. This will save you from a lot of trouble.
UPDATE 08/10/22: It turned out today that your user name also may not have a space within it. I've just spent an hour trying to get weave working on a colleague's computer where the username is actually a "user name". No, renaming the user does not do the trick. I 'solved' it by creating a new user with 'valid' username.

Strange scipy.weave import error

2008-08-19T13:47:00.000+02:00

Today, I've booted my PC and tried to run a script which uses scipy.weave package. What I got was a rather unusual error:

EOFError: EOF read where object expected

I've tried to type

import scipy.weave

which just reproduced the error. After some thinking I got an idea that some files were broken. A scipy reinstall however warned that some files are broken and cannot be (re)written. So I run the scandisk/chkdsk/whatever its name currently is. It did find some errors within files mentioned in the error message. Nonetheless the import still didn't work, this time replying with another error:

ValueError: bad marshal data

After this I tried repairing both scipy and Python installations to no success. No warnings this time though.
Finally, I uninstalled Python alltogether and deleted all files and directories within C:\Python25\. After installing everything back everything seems to fine allright. I think it is the first such error since I've started using NTFS as my filesystem some five or six years ago.

Text box with scrollbar

2008-08-18T09:25:00.003+02:00

A very nice example can be found here.
I you want to move focus so that the last entry in the text box will be visible, you may modify the code as follows:


import Tkinter

root = Tkinter.Tk()
s = Tkinter.Scrollbar(root)
T = Tkinter.Text(root)

T.focus_set()
s.pack(side=Tkinter.RIGHT, fill=Tkinter.Y)
T.pack(side=Tkinter.LEFT, fill=Tkinter.Y)
s.config(command=T.yview)
T.config(yscrollcommand=s.set)

for i in range(40):
   T.insert(Tkinter.END, "This is line %d\n" % i)
   T.yview(Tkinter.MOVETO, 1.0)

Tkinter.mainloop()

The 1.0 parameter of .yview means the end of the Text widget contents.
I'm usually using the Grid geometry manager and aligning the scrollbar with it requires some more work than with pack. Nothing out of ordinary though.

Filenames, paths, .zip files and such in Python

2008-08-08T11:15:00.002+02:00

It may be hard to believe but I've had troubles looking for a way how to split a path to a file into filename and the path to it. So here it is. Let's have a path such as this:

'C:/Python25/python.exe'

we want to separate a file name 'python.exe' from the path to it 'C:/Python25/'. With the help of a standard Python module os.path it is an easy task to do:


import os.path
mypath = 'C:/Python25/python.exe'
separated = os.path.split(mypath)

where 'separated' is a tuple with two items. First is the path, second is the filename.
Do you also want to separate file name from its extension (e.g. '.exe' in our case)? It's easy:


name,extension = os.path.splitext(separated[1])

Do you also want to reverse this process? Just call the os.path.join() function:


completefilename = os.path.join(separated[0],separated[1])

Finally, I also wanted to compress some files to save disk space. There is a standard Python library called zipfile which supports creating .zip files (it also requires another library called zlib for compression of the .zip archives). Usage is simple:


import zipfile
f = zipfile.ZipFile( 'myfile.zip', 'w', compression = zipfile.ZIP_DEFLATED)
f.write('mydata.txt')
f.close()

The 'ZIP_DEFLATED' option tells the ZipFile class to compress the data, otherwise no compression is done.

Windows XP Home won't allow login after installation, domain error

2008-07-28T09:19:00.007+02:00

I've recently installed Windows XP Home to a computer which was previously equipped with Win XP Professional. There was a minor glitch during the installation when the installer refused to delete the C: partition because there were some installation files present. This was possibly caused by inserting the install CD into running computer, the installer then copied some files into C: and expected to put Windows on a D: or E: partition. After reset a new installation started and run OK. Unfortunately, I couldn't log in into the machine although I haven't set any password for the only user account set up during installation. The message was "Domain does not Exist" with "smart" advice to contact system administrator. I've found several questions posted on the web regarding the same problem but no real answer to the problem. The trouble is, I have not set up any domain and Win XP Home officially does not even support domains!
My conclusion was that the installer somehow picked up some remnants of the previous Win XP Pro system (which does support domains but on this PC was not using them) and malfunctioned.

So I've done a reinstall with following steps:
1) format not only C: but also D: partitions;
2) full format on C: to NTFS before system installation begins (i.e. not the fast formatting option); it takes about 12 minutes on a 50 GB partition;
3) different user name from the previous (XP Pro) system.

I'm not sure whether these steps are all necessary or which one did the trick but after second installation everything works as it should.

Showing a webcam image in the desktop window using Python. Part 3: self-refreshing app

2008-07-10T18:05:00.001+02:00

This is the last part of a three-part series. In the first part, I've described how to read image from the web. The second part was dedicated to showing images in a window on the desktop. This last part will deal with auto-refreshing of the displayed image. This is particularly useful when you want to display a webcam image which is regularly updated.
To handle autorefresh we will use a Tkinter method after() which will call a defined function after some given delay.
To the previous code, we will add the following function:


def timingloop(start=0):
  now = time.clock()
  if start == 1:
      getimagefromweb(myurl)
  if now > container.start + container.refresh:
      getimagefromweb(myurl)
      container.start = now
  else:
      remains = str(int(container.refresh - now + container.start))
      message = 'Next update in '+remains+' seconds.'
      container.statusbarVar.set(message)
      container.statusbar.update()
  container.main.after(200, timingloop)

This function controls downloading new images by calling getimagefromweb() and checks when to do it by comparing saved times with current time. Finally, the function calls itself after 200 miliseconds.
For the program to work you also have to add some other stuff into the code. To the beginning add "import time" to import time library. The last part of the script has to be slightly modified as follows:


# the script
myurl = 'http://siemens.mesto-zatec.cz/obrazek.jpg'
container = Container()
container.width = 800
container.height = 602

container.start = time.clock()
container.refresh = 20 # window refresh rate in seconds

drawwindow()
timingloop(1)

mainloop()
print 'end OK'

We have added two new variables with timestamp and a refresh rate in seconds after which the image will be re-loaded. Finally, the getimagefromweb() function has been replaced by the timingloop() with parameter "1" which tells it that it is the start of the program and that it should load the image immediately. After the first timingloop() there is enough time to call mainloop() without which the program hangs (and I'm not sure why). As you can see using after() is a bit unintuitive because you can call other functions after "after()" was called and is still running in the background.

Showing a webcam image in the desktop window using Python. Part 2: displaying images in windows

2008-07-08T06:14:00.002+02:00

In the previous post I have shown how to download an image from web with the use of Python. Today I will show code which takes this image and draws it in a standalone window.
Before we start it is necessary to be prepared somewhat. You need a specialised library to make windows. I 'm using Tkinter which comes with Python as default. There are more options like wxwidgets but I've started with Tkinter and so far it has covered all my needs. It seemed quite tricky to learn so I have found a good tutorial on Tkinter and learned it that way. Unfortunately, it is only in czech and currently seems offline so I cannot link to it anyway :-(.
To deal with images I'm using the PIL or Python Imaging Library. This you will need to download and install in order to use following code. Good news is that it's free :-)
Programming windowed applications is a lot more complicated than simple beginner stuff and in today's code there are commands which I don't know why they are there...
The code:


from Tkinter import *
import urllib
from PIL import Image, ImageTk

class Container:
    pass

def drawwindow():
    main = Tk()
    main.title('Zatec webcam')      # window title
    main.resizable(width=False, height=False)
    container.main = main
    container.canvas = Canvas(main, width=container.width, height=container.height)
    container.canvas.pack(expand=1, fill=BOTH)
    container.statusbarVar = StringVar()
    container.statusbar = Label(main, textvariable=container.statusbarVar)
    container.statusbar.pack()
    container.statusbarVar.set('Ready.')
    container.statusbar.update()


def showimage(image):
    '''Loads given image and puts it into the window'''
    img = Image.open(image)
    photo = ImageTk.PhotoImage(img)
    container.canvas.create_image(container.width/2+2, container.height/2, image=photo)
    container.obr = photo # why is this line necessary?

def getimagefromweb(url):
    '''Downloads content from given url and saves it as image.'''
    container.statusbarVar.set('Reading new image from web...')
    container.statusbar.update()
    try:
      u = urllib.urlopen(url) # open url
      container.statusbarVar.set('Url opened...')
      container.statusbar.update()

      content = u.read()      # read the opened url
      container.statusbarVar.set('Url read...')
      container.statusbar.update()

      u.close()               # url was closed
      container.statusbarVar.set('Url closed...')
      container.statusbar.update()

    except IOError:
      print('IOError')
      pass
    except:
      print('Unknown url error')

    # saving what was downloaded
    f = open('img.jpg','wb')
    f.write(content)
    f.close()   # file was closed
    
    # showing the image
    showimage('img.jpg')
    container.statusbarVar.set('Ready.')
    container.statusbar.update()

# the script
myurl = 'http://siemens.mesto-zatec.cz/obrazek.jpg'
container = Container()
container.width = 800
container.height = 602

drawwindow()
getimagefromweb(myurl)

mainloop()
print 'end OK'

The class Container is used to store information which is passed between functions. The code could be rewritten to form a single class but it works this way too :-).
There are three functions. Drawwindow is used to create window with desired elements in it (Canvas and Label). To provide some info on download status there is a text in the Label. This is done with the help of StringVar() which is from Tkinter library. If we used only a string, it would be immutable later on. After the Label is changed, an .update() function must be called to change it on the display too.
The showimage() function gets an image file from disk and puts it into the Canvas. There is some magic in it, sorry about that.
The third function, getimagefromweb(), is adopted from previous post by adding info into the Label and after the image saved it calls the showimage() function.
In the script, we first draw the window elements with drawwindow() and then download an image and paste it into the Canvas with getimagefromweb().
The last command, mainloop(), tells Tkinter that we are ready and draws everything on the display. Without this command nothing will be shown (though it will be ready). Also, after mainloop is called, the focus is changed from your script to the GUI which is driven by user action. After you close the window the focus is returned to your python script.

Showing a webcam image in the desktop window using Python. Part 1: reading image from web

2008-07-06T10:23:00.018+02:00

I will describe everything that is necessary to show a window with a webcam (or any other) image in it. I'm using similar app to display a stock price chart (downloaded from a website) which is regularly updated. I will divide the text into three parts because I think this will be easier to grasp than one large article. This part will deal with downloading web content, in the second one the content will be displayed and in the third, final, one I will cover the self-refreshing which was the most difficult to figure out.
Again, I believe there is more than one way to do it. What follows is how I solved it.
There is a nice built-in library in Python called urllib which we will use to download the image in question.
The code is simple:


import urllib

def getimagefromweb(url):
   '''Downloads content from given url and saves it as image.'''
   try:
       u = urllib.urlopen(url) # open url
       content = u.read()      # read the openned url
       u.close()               # url was closed

   except IOError:
       print('IOError')
   except:
       print('Unknown url error')

   # saving what was downloaded
   f = open('img.jpg','wb')
   f.write(content)
   f.close()   # file was closed


myurl = 'http://siemens.mesto-zatec.cz/obrazek.jpg'
getimagefromweb(myurl)
print 'all OK'

The (only) function "getimagefromweb" receives a url with content to be downloaded and then reads from this adress in the same way that is used when reading/writing files. When dealing with web it is very advisable to use error-catching code like this one. It is common that the website will not respond in time and without error catching your application would crash.
As a final task the function saves image to harddisk so that it can be later re-read and shown on the desktop. This is a workaroud because I could not figure out a way how to display it directly.
The url leads to the webcam of the main square of the Zatec city where I was born and have grown up. It has quite interesting medieval centre so its nice to have it shown on desktop :-)

How to make a simple .wav file with Python

2008-07-04T06:15:00.007+02:00

EDIT: I've edited this code a little and incorporated reader's comments, here's the new version

I've recently had an idea to test some vibration-resonance problems by playing a set of sounds and detecting the vibrations in question. The glitch is, how to create a sound of desired frequency? I believe there is a lot of ways to solve this but having only a hammer (read Python) as my tool it looked like a nail ;-)
The idea is then to create a simple sine wave and play it back with a computer. My first try was with pygame module but the sound quality was poor and unsatisfactory.
If not playing sound directly one can write the wave to the file and then play the file with whatever means are suitable. This turned out to be the better way after all.
A search of the internet turned up this discussion of creating .wav files with Python. I've adopted the "minimal example" from there (written by Andrea Valle) to be usable with modern modules (it used obsolete Numeric and RandomArray modules). The code is not neat but it works well.


import numpy as N
import wave

class SoundFile:
   def  __init__(self, signal):
       self.file = wave.open('test.wav', 'wb')
       self.signal = signal
       self.sr = 44100

   def write(self):
       self.file.setparams((1, 2, self.sr, 44100*4, 'NONE', 'noncompressed'))
       self.file.writeframes(self.signal)
       self.file.close()

# let's prepare signal
duration = 4 # seconds
samplerate = 44100 # Hz
samples = duration*samplerate
frequency = 440 # Hz
period = samplerate / float(frequency) # in sample points
omega = N.pi * 2 / period

xaxis = N.arange(int(period),dtype = N.float) * omega
ydata = 16384 * N.sin(xaxis)

signal = N.resize(ydata, (samples,))

ssignal = ''
for i in range(len(signal)):
   ssignal += wave.struct.pack('h',signal[i]) # transform to binary

f = SoundFile(ssignal)
f.write()
print 'file written'

This code should work as intended and produce .wav files of given length and frequency. A few comments:
a) if you need different sampling frequencies, just replace all 44100 numbers with desired sampling frequency;
b) the setparams command is relatively well described in wave doc in Python help, its fourth parameter (nframes) may probably be whatever number you want, the procedure is designed to write all data you sent to it;
c) the 16384 number seems to be a volume setting for .wav file, this value is near the maximum so only lowering the volume is possible from here;
d) wave.struct.pack('h', #) - this was tough to find but without this command the resulting file will not be correct (at least on Windows machines), I do not yet understand what it does...

Introductory and testing first post

2008-07-03T09:54:00.006+02:00

Hello there, whoever reads this!
I've started this blog to collect my dilluted and unorganized programming and general computer knowledge. I'm not a full time programmer and all of my coding skills were self-taught. There are long periods of time when I'm not coding and having bad memory this causes me to forget anything I've ever known. After a year without programming I usually even forget the basic language commands and syntax.
This site is dedicated to preserving some of my present knowledge for future reference by anybody who may be interested in it.
I've a long history of programming languages including Basic, Pascal, C/C++, Matlab and, more recently, Python.
I'm currently a scientist-in-training and I've found Matlab to be a very fine and powerful tool. Unfortunately the price is quite prohibitive for occasionally used software and for random playing. I believe Python is a very good replacement of Matlab (at least for most of my purposes) and recommend it to anyone who might appreciate simple syntax, fast development and high portability. In connection with some add-on modules like SciPy I believe it can compete with Matlab on even grounds.
As a sideline I also intend to use this blog to learn some web-creating skills.
That'll be all for now.
R.L.