A Place for Asides

Saving His Life by Lee Sandlin

2020-04-12T23:00:00+02:00

The first article I have read of Lee Sandlin was Losing The War. Losing The War was featured in Ira Glass' anthology The New Kings of Nonfiction. This led me looking for more articles by Lee Sandlin. Many of his popular articles are freely available on his personal page and that is where I found his article Saving His Life.

In Saving His Life Lee Sandlin chronicles the life of his father-in-law Nick Cherniavsky. The story of how Nick ended up in the US is very interesting. Nick lived in different Russian communities in Asia and eventually arrived in the USA as a refugee.

His memoirs show the interesting history some cities in Asia share. They served as a meeting point for many ehnic groups. These circumstances were created by the many wars for territory in the first half of the 20th century and the preceding expansive colonialism by the global powers. Nick's memories of cities like Shanghai and Tsingtao give the impression of a globalized world without the many technologies we commonly associate with the term today.

It is also a story about a time where, from our perspective, these seemingly large and well-remembered events happened. Events later generations would learn about in history class. The type of events that if occurred today, would break up the daily routine and keep everyone hooked to their TV (or smartphone nowadays).

But back then information didn't spread as fast and the way Nick learns about different historical events is fascinating. It is interesting to see how these global events are interwoven into Nick's life in many different ways.

The article is rather long, which makes reading it on your web browser not always very practical. I have converted the story to the .epub format, so that someone interested in reading Saving His Life can comfortably read it on their eBook reader:

Download Lee Sandlin's Saving His Life for your eBook reader

I hope you enjoy Lee Sandlin's article as much as I did.

Using the Infrared Camera of the Dell XPS on Ubuntu 18.04

2019-11-05T17:55:00+01:00

I was interested in using the unusual webcam setup of my Dell XPS 13 9370 notebook for some personal projects. The Dell XPS 13 9370 does not only have a regular color camera but also an infrared camera. On Windows the infrared camera and the color camera are used for Windows Hello, which allows the user to secure his PC using facial authentication (Howdy is the closest equivalent for Linux). But when I tried to access my infrared camera using tools like fswebcam or installing Howdy I ran into several issues.

It turns out that the infrared camera of the Dell XPS 13 9370 uses an unusual 8-bit infrared video format called L8_IR (see this GitHub Issue for Howdy). This format is currently not supported by the driver in Ubuntu 18.04, but it was added to the linux kernel 4.19 (see the commit here) and that kernel version is expected to then be available on Ubuntu 19.04. That's good to know, but I still wanted to find a way to make use of the infrared camera on Ubuntu 18.04.

Following an approach similar to NSchrading on Stack Overflow I tried to make sense of the raw data produced by the infrared camera using the following fswebcam command:

LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libv4l/v4l1compat.so fswebcam --palette GREY --device RAW:/dev/video1 --no-banner --no-timestamp --resolution "340x340" --dumpframe ir.raw

The command contains many optional arguments, so I will briefly break down what the individual arguments do:

LD_PRELOAD provides the absolute path to the Video4Linux library on my system, which has to be preloaded for fswebcam to correctly read from the raw video source of the infrared camera. You might have to change this path if Video4Linux is stored somewhere else on your system (see this comment on how to find the v4l1compat.so).
--palette GREY is the closest palette format supported by fswebcam to L8_IR.
--device RAW:/dev/video1 specifies that we are reading the raw video data provided by the infrared camera, the color camera is found at /dev/video0.
--no-banner --no-timestamp remove the default banner added by fswebcam.
--resolution "340x340" defines the image resolution of the infrared camera, which is specified here by Dell.
--dumpframe specifies that we want to dump the raw frame to a file.

So running this command gives us an ir.raw file. You can also notice that the infrared emitters light up red when taking an infrared image.

Most programs cannot view .raw files, for this I wrote a quick script to validate if we are actually downloading a valid 8-bit infrared image. This blog post by a Linux driver developer for camera devices explains very well how the different color formats for Video4Linux2 are defined using the fourcc coding mechanism. The fornat for our 8-bit infrared format is V4L_PIX_FMT_GREY. So one byte describes the grayscale value for the given pixel. With this knowledge and knowing the output resolution of the infrared camera, we can write the following script to display the infrared image using matplotlib:

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

grays = np.zeros((340,340),dtype=int)

with open('ir.raw', 'r+b') as f:
    for i in range(340):
        for j in range(340):
            val = f.read(1)
            pixel = int.from_bytes(val, byteorder='big')
            grays[i,j] = pixel

plt.imshow(grays, cmap='gray')

Here is an example image produced by my infrared camera:

So it took quite a bit to get to this point, but now we have the tools to implement some interesting Computer Vision applications using the stereo image setup of the Dell XPS 13 9370. I hope this is useful for other Dell users trying to get started with the built-in infrared camera.

Using binvox-rw-py with Python 3

2018-10-30T23:00:00+01:00

Using binvox-rw-py with Python 3

The Python project binvox-rw-py is based on the binvox project from Patrick Min. It is a simple and easy-to-use tool to convert 3D model files into 3D voxel grids (it supports most of the common 3D model file formats: .obj, .ply, .stl; the output format is typically the custom .binvox file format).

Some research projects in the field of 3D machine learning may use this library to create voxelized scenes for training. These voxelized scenes are used to train networks to learn a rudimentary understanding of the scene's geometry in a more easily quantifiable way. This is how I stumbled upon the binvox-rw-py module, which enables you to read .binvox files as 3-dimensional Numpy arrays in Python. You can also write numpy arrays into .binvox using binvox-rw-py.

Troubles with writing .binvox files in Python 3

The original binvox-rw-py from the GitHub user dimatura has issues with writing .binvox files when running it in Python 3, since it was implemented with the byte handling of Python 2 in mind. I discovered this after a few frustrating hours by simply reading and writing the same .binvox file I generated for my project and comparing the resulting voxelized scenes using viewvox (which is also from Patrick Min):

Luckly, the GitHub user pclausen has already created a forked version of the binvox-rw-py module that resolves this issue. This makes it possible to also use binvox-rw-py with Python 3.

Unfortunately, the fixed binvox-rw-py module by pclausen does not seem as well known as the original module by dimatura if you compare the number of stars for each GitHub repository (at the time of writing dimatura's repository has 69 stars, while pclausen's repo only has 2 stars). pclausen has even originally created an issue in dimatura's issue tracker for the binvox-rw-py regarding the Python 3 writing issue. The issue has not been closed even until today.

So I hope this post could help someone, who has been having issues using binvox-rw-py with Python 3 and save the person some time when trying to find the bug in his code.

To install pclausen's binvox-rw-py module using pip, simply write the following command:

pip install git+https://github.com/pclausen/binvox-rw-py

Installing pip for Python in Blender

2018-09-30T18:05:00+02:00

If you are working on a Computer Vision project in Python that requires 3D scene renderings, then Blender is the way to go. Blender comes bundled with its own Python version, which can be used to write Python scripts for Blender. This is useful for automating rendering jobs, since Python in Blender provides you the bpy module, which gives you access to Blender data, classes, and functions.

Unfortunately, the Python in Blender does not share libraries with your system's Python. But if you don't want to be limited to the Python Standard Library available for Python in Blender, then you can install pip for Python in Blender.

The blender Python binaries are here in the blender directory:

/your-blender-path/2.xx/python/bin/python.exe

Use this python binary to run the get-pip.py script from the pip documentation to install pip for Python in Blender. Don't forget to point explicitly to the python binary from your blender version. The installation command will look something like this:

/your-blender-path/2.xx/python/bin/python.exe /Downloads/get-pip.py

I ran the installation on Windows, which required me to open a Terminal with admin priviliges to execute the pip.exe. Use this version of pip from Python in Blender (not the pip from your system's Python) to install 3rd party modules for Blender in Python:

/your-blender-path/2.xx/python.exe pip install module

This should allow you to install 3rd party modules for your scripts in Python in Blender.

References

Read these StackExchange questions for more information on installing pip for Python in Blender. My post is based on their answers:

Installing legacy PyTorch for Windows

2018-09-12T14:20:00+02:00

It can be useful to have a working version of PyTorch installed on your outdated local Windows machine to be able to run the prediction of pre-trained models written in PyTorch. I encountered a few roadblocks during my installation, where I really wished for more information on the web somewhere. Therefore, here are some notes I have made while installing PyTorch on my outdated laptop (Acer Aspire from 2013).

You cannot run the most recent version of PyTorch (0.4.0 at the time of writing) with GPU support on an older machine with an outdated graphics card. In my case my Acer Aspire from 2013 has a NVIDIA GeForce GT 750M. The GeForce GT 750M has a CUDA compute capability of 3.0. You can look up the compute capability of all CUDA GPUs on this official NVIDIA page. The most recent version of PyTorch that still supports a GPU with a compute capability of 3.0 is PyTorch 0.3.0.

This GitHub repository from user peterjc123 is very helpful when trying to install PyTorch on Windows. The windows-specific PyTorch packages are available as conda packages here. The README of this repository also refers to a Google Drive that includes conda packages for legacy versions of PyTorch for Windows. Here you have to check for the correct conda package. In my case I am running Python 3.6 and CUDA 8.0. I had to download the following compressed package:

pytorch_legacy-0.3.0-py36_0.3.0cu80.tar.bz2

Move the compressed conda package to your working directory. Now you can locally install this conda package in your conda environment with the following command.

conda install --offline pytorch_legacy-0.3.0-py36_0.3.0cu80.tar.bz2

You can quickly check if this version of PyTorch correctly detects the CUDA installation in your Python interpreter with the following commands:

import torch
torch.cuda.is_available()

If this returns True then you should be ready to run legacy PyTorch on Windows.