Blog | dr. Sybren

Dynamic DNS tool for TransIP

Fri, 02 Jan 2026 16:13:03 +0100

My domains, like stuvel.eu and stüvel.eu, are hosted by TransIP. I’m in the process of moving all my websites to some hardware at home, and my ISP contract does not give me a fixed IP-adress. And since I didn’t like the solutions I found online, I made my own.

TransIP DynDNS is a tool that periodically checks its own public IP address, and if it changed, uses the TransIP API to update DNS records. That way, these records are always pointing to the right address, ensuring my websites remain reachable.

Example Configuration

general:
  IPv4: true
  IPv6: false   # Unfortunately my current ISP doesn't offer IPv6 yet.
  watch-period: 5m
account:
  username: TRANSIP_USERNAME
  private-key: /path/to/transip-dyndns.pem  # Private key obtained from TransIP.
records:
  # Expanded notation:
  - domain: example.com
    entry: my-home
    type: A

  # Collapsed notation:
  - { domain: "example.com", entry: "my-home", type: A }

  # By not specifying the type, both A and AAAA records will be updated.
  # This also depends on whether IPv4/IPv6 are disabled above.
  - { domain: "example.com", entry: "my-home" }

  # Types other than A or AAAA need an explicit 'content field.
  # {{.IPv4}} and {{.IPv6}} will be replaced with the current IP address.
  - { domain: "example.com", entry: "my-home", type: TXT,
      content: "v=spf1 ip4:{{.IPv4}} ip6:{{.IPv6}} include:thirdpartydomain.com -all" }

There’s more information in the README file.

Thanks

Many thanks to J Lentink for making a similar tool, and releasing it under the MIT license. It helped me to build this tool, which is a bit simpler to use. Mine has a smaller config, is therefore easier to update, and it performs less API calls.

Python-RSA project has been archived

Wed, 16 Apr 2025 10:42:06 +0200

I’m one of the original authors and the maintainer of Python-RSA. Unfortunately I don’t have the time and brain space left to properly maintain Python-RSA. As you can see from the lack of activity on the open issues, and the lack of commits, that has been the case for a while now.

As Python-RSA is included as a dependency in quite a few high-profile projects, I don’t feel comfortable handing over the project to someone else. It’s just too big of a risk.

Thanks for having used this little library for so long, and in so many projects. I truely didn’t expect that when I started working on it. Also big thanks to all the people helping out and improving the project.

There are improvements that haven’t made it into a new release. As I said, I don’t have the time and the brain space to really investigate and oversee the security impact of all those changes. It’s not a decision I’ve made lightly.

So that’s it. If you want to keep the project alive, please fork it. Give it the love it deserves, investigate those yet-unreleased improvements, and have a project that’s then already better than how I left this one.

Blender Conference 2024

Sun, 27 Oct 2024 22:43:38 +0100

Blender Conference 2024 was amazing again, as always. Our talk A New Animation System - Progress Report was also received very well.

Presentation

Slides

Blender Conference 2023

Sun, 27 Oct 2024 21:43:38 +0100

This blog post I wrote after the 2024 conference, just so that the slides are available here as well.

A New Animation System

Animation & Rigging module presentation about the plans for a new animation system.

Video

Slides

Flamenco v3.3 hands-on class

Hands-on class about installing & using the Flamenco render farm.

Video

Slides

New Website Section: Electronics

Wed, 10 Jan 2024 22:11:29 +0100

I’ve just added a new section to this website: Electronics!

Sometimes I just want to share my electronics projects. Even though I design them in a web-based tool (EasyEDA), and that also has a sharing feature, I want to have my own projects on my own website. That way I own the data, and also I can write an article, combine some things together, and make it overall a better place for my purpose.

Go check out my first published project: Bicycle Lights

webp presets

Fri, 20 Oct 2023 13:01:11 +0200

When exporting WebP images from Gimp, there is a selector for the “Source Type”. I’ve always wondered what these options mean, and today I found the info.

GIMP exporter options for WebP images

Apparently the only place where this is available is in the actual source code of the webp encoder. Fortunately Jon Jensen dove in there and wrote about it on their blog:

Picture: digital picture, like portrait, inner shot
Photo: outdoor photograph, with natural lighting
Drawing: hand or line drawing, with high-contrast details
Icon: small-sized colorful images
Text: text-like

Of course it’s all still very subjective. What is “small-sized”? What if I take a digital photograph inside of a coffee cup? In any case this is the official explanation, and for now I’m happy I have at least something to go on.

Compose Key on Windows

Mon, 31 Jul 2023 11:39:39 +0200

My last name is Stüvel, and it causes all kinds of issues on various systems. Since in the Netherlands people typically use a keyboard with US layout, there is no ü key. So how do I type my name? Compose key to the rescue.

On Linux I type the ü by using the Compose key. Since modern keyboards don’t have such a key, I’ve configured my right-hand Alt key to become Compose. To type ü, I press Compose, ", u. One after the other, I don’t have to keep three keys pressed at the same time.

I can hear you think: isn’t what US International layout is for? Yes, and no. With that layout I can shave off a key, and type ", u instead. However, every time I want to have just single or double quotes, I have to type ", <space>, doubling the number of keys necessary. As a software developer, this is unacceptable to me, because I have to type these quotes so often.

Additionally, the Compose key expands far beyond accented Latin characters:

Compose Sequence	Result
`"`, `u`	`ü`
`1`, `2`	`½`
`e`, `=`	`€`

Compose Sequence	Result
`<`, `3`	`♥`
`o`, `c`	`©`
`^`, `0`	`⁰`

Now, most Linux systems have built-in support for the Compose key, but Windows does not. Fortunately I recently found WinCompose, which fills in that gap pretty well. It’ll now get installed by default on any of my Windows machines!

Flatterer v1.5 released

Sun, 16 Apr 2023 00:16:38 +0200

Flatterer v1.5 has just been released! It adds new operators:

Extrude Finger: easily create finger connections between laser-cut parts. Select some edges and click Extrude Fingers to extrude them in just the right direction, using the material thickness.
Separate Mesh into Faces: split up the mesh into separate objects for each side.
Align to Local Axis: rotate the mesh to align it with the object’s local axes, then counter-rotate the object so that everything stays in place.

Check Out Flatterer

Flatterer turns a 3D model in Blender into a set of shapes suitable for laser cutting. It’s aimed at easily exporting boxes, enclosures, and other made-for-laser-cutting designs to SVG.

For the full list of features check the Flatterer software page.

Gitea Pull Requests

Fri, 17 Feb 2023 15:35:05 +0100

Since Blender moved to Gitea I’ve struggled a bit with the pull requests workflow. Getting contributors’ changes onto my machine wasn’t as simple as I wanted it to be. So, I wrote a little shell script to make my life easier.

The functions below I store in ~/.config/fish/conf.d/aliases.fish. Once they’re installed, I have these commands at my, well…, command:

Update 2024-04-03: I’ve started to track those scripts at my projects.blender.org profile space. Go there to get the latest versions.

`pr NUMBER [-o owner] [-r repo]`

I can just type pr NUMBER to get a Blender pull request, for example pr 104512. It will:

Create a branch named PR/104512/author-branch
If that branch already existed, it gets removed before creating a brand new one.
Pull in the changes from the PR.
The options -o and -r are optional, and both default to blender. I use this for Flamenco pull requests, for example, like pr -o studio -r flamenco 12345.

The branch is named like this so that I can easily find it back later.

Update 2023-03-06: addition of the -o and -r options.

`prprune`

This removes all the branches named PR/.... I use it to periodically clean things up.

The code

Store this snippet in ~/.config/fish/conf.d/aliases.fish:

function pr -d "Pull in a Blender pull request"
    # Set defaults
    set _flag_owner blender
    set _flag_repo blender

    argparse 'o/owner=' 'r/repo=' -- $argv
    or return 48

    set PRNUM $argv[1]

    set JSON "pr-$PRNUM.json"
    set URL "https://projects.blender.org/api/v1/repos/{$_flag_owner}/{$_flag_repo}/pulls/$PRNUM"
    curl -s -o$JSON $URL
    or return 49

    set PR_STATUS (jq -r .state <$JSON)
    if [ (jq -r .merged <$JSON) = "true" ]
        printf "\033[92mPR is already merged, check $URL\033[0m\n"
        echo "Merged at:" (jq -r .merged_at <$JSON)
        echo "Merged by:" (jq -r .merged_by.full_name <$JSON)
        return 51
    end
    if [ (jq -r .state <$JSON) = "closed" ]
        printf "\033[91mPR is closed, check $URL\033[0m\n"
        return 50
    end

    set PR_NUM (jq -r .number <$JSON)
    set PR_TITLE (jq -r .title <$JSON)
    printf "\033[95mPulling #$PR_NUM: $PR_TITLE\033[0m\n"

    set PR_REPO (jq -r .head.repo.full_name <$JSON)   # "ChrisLend/blender"
    set PR_AUTHOR (jq -r .head.repo.owner.username <$JSON)   # "ChrisLend"
    set PR_BRANCH (jq -r .head.ref <$JSON) # "vertical_scrolling_offscreen"
    set LOCAL_BRANCH "PR/$PRNUM/$PR_AUTHOR-$PR_BRANCH"

    printf "\033[90mIncoming branch: $PR_REPO\033[0m\n"
    printf "\033[90mLocal branch   : $LOCAL_BRANCH\033[0m\n"

    rm -f $JSON

    set CURBRANCH (git branch --show-current 2>/dev/null)
    if test "$CURBRANCH" != "main";
        git checkout main
    end
    if git branch | grep -q $LOCAL_BRANCH;
        printf "\033[95mBranch $LOCAL_BRANCH exists, going to refresh it\033[0m\n"
        git branch -D $LOCAL_BRANCH
    else
        printf "\033[96mBranch $LOCAL_BRANCH does not exist\033[0m\n"
    end

    git checkout -b $LOCAL_BRANCH main; or return 47
    git pull --ff --commit https://projects.blender.org/$PR_REPO $PR_BRANCH; or return 48

    printf "\033[95mBranch $LOCAL_BRANCH is ready for use\033[0m\n"
    printf "\033[94mPulled #$PR_NUM: $PR_TITLE\033[0m\n"
end

function prprune -d "Delete all PR/* branches"
    set BRANCHES (string trim (git branch | grep '^  PR/'))
    if test -z "$BRANCHES";
        echo "No PR branches to prune"
        return 0
    end
    git branch -D $BRANCHES
end

Note that I wrote similar code for Phabricator in my Fish and Gits post, which also shows more of my Git config.

Gitea Easy Linking

Thu, 09 Feb 2023 14:59:33 +0100

Since this week, Blender development has moved from Phabricator to Gitea on projects.blender.org. Even though much of the workflow has changed, I still have the need to reference issues, pull requests, and commits from other places, like chats, forum discussions, my work log, etc.

Just like I did for Phabricator, I created a little GreaseMonkey script to add some useful buttons to the Gitea interface.

First download the Greasemonkey add-on for your browser (for Firefox or Chrome/Chromium-based browsers), then add the script:

Get the Script

Then visit an issue page. You should see buttons next to the issue title: “MD”, “TXT”, and “Wiki”. Which ones appear depends on whether you’re looking at an issue/PR or a commit.

Flatterer v1.4 released

Sat, 07 Jan 2023 16:35:33 +0100

Flatterer v1.4 has just been released! It adds support for engraving edges and comes with an improved GUI.

Check Out Flatterer

Flatterer turns a 3D model in Blender into a set of shapes suitable for laser cutting. It’s aimed at easily exporting boxes, enclosures, and other made-for-laser-cutting designs to SVG.

Of course the add-on automatically applies kerf compensation, so there is no need to manually move edges around. For the full list of features check the Flatterer software page.

Flatterer v1.3 released

Sat, 31 Dec 2022 12:05:40 +0100

Flatterer v1.3 has just been released! It adds the export of multi-page SVG files, where each page represents a slab of cuttable material. Each page is also seen as an Inkscape layer.

Tools that don’t support pages, like LightBurn, will see them as groups instead, still keeping it simple to select one such group and cut out only those before putting on a new plate of material on the cutting bed.

Check Out Flatterer

Flatterer turns a 3D model in Blender into a set of shapes suitable for laser cutting. It’s aimed at easily exporting boxes, enclosures, and other made-for-laser-cutting designs to SVG.

Of course the add-on automatically applies kerf compensation, so there is no need to manually move edges around. For the full list of features check the Flatterer software page.

Keychron Function Keys on Linux

Fri, 09 Dec 2022 11:31:26 +0100

Recently I bought a Keychron K5 SE keyboard (with clicky blue optical switches, thank you for asking). When I started using it on an Ubuntu Linux machine, it worked great except one thing: the F1-F12 function keys did not work well. As with so many laptops and other keyboards, they defaulted to their “special” meaning, controlling brightness, volume, that kind of thing. The real issue, though, is that fn + F-key did not work either.

This is due to the Linux kernel recognising the keyboard as an Apple keyboard clone. Fortunately it’s easy to revert that:

echo 0 | sudo tee /sys/module/hid_apple/parameters/fnmode

This command should immediately make F-keys register as normal function keys, so F5 actually works as F5. Try pressing it to reload this article!

This fix works immediately, but doesn’t survive reboots. To make the fix permanent:

echo "options hid_apple fnmode=0" | sudo tee /etc/modprobe.d/hid_apple.conf
sudo update-initramfs -c -k all  # To make sure it's loaded early enough.

I was put on this path by Jeremy Cheng’s article on the same topic. Only a minor change was needed (putting 0 there instead of the 2 he uses). And I needed to add the update-initramfs command for my Ubuntu install. Thanks Jeremy!

Learning to Draw

Sun, 04 Dec 2022 13:01:23 +0100

To get more into the fundamentals of animation, I’m learning how to draw! Bought an Apple Pencil 2 to draw on my iPad, and I like it a lot. For now I keep things simple, with a (simulated) pencil and black-and-white drawings. Drawing bugs also makes it a nicer experience, because when I mess up the proportions, it still looks like a bug.

I share my drawings on Mastodon, at https://fosstodon.org/@sybren. There’s also an RSS feed of my Mastodon posts if you’d rather use that.

On a somewhat unrelated note, I just wrote an article GPS Waypoint Deduplication. It’s about how I deduplicated my Osmand favourites with a bit of Python code. And of course I had to seize this opportunity to use my new drawing skills for a little flow diagram of the process :)

Blender Conference 2022

Mon, 07 Nov 2022 16:00:10 +0100

Finally, after three years, there was another Blender Conference! With 700+ participants it was bigger than ever, and of course the energy was amazing. There were so many talks, and many of them high quality. The image above is not me, btw ;-)

For me the highlight was the Character Animation workshop that we did just before the conference, and having most of the Animation & Rigging module there in the flesh – some others joined for the conference itself. Being together and working on big new ideas really worked well for the energy & enthousiasm in the team. So much passion!

This year I had two talks:

The Future of Character Animation & Rigging

The aim of this presentation was not just to talk about the workshop & its outcomes, but also to solicit feedback on the presented ideas from a wider audience.

Distributed rendering with Flamenco v3

Flamenco v3 has been released just over a month ago! Aimed at simplicity and interactivity, the render management software used by Blender Studio is now considered to be featured and stable enough that anyone can use it in their production. In this talk Sybren will show how to get it working for various situations, from simple use at home to the setup used by Blender Studio for their current production.

And the slides:

Python-RSA 4.9 released

Wed, 20 Jul 2022 12:32:23 +0200

The final release of Python-RSA v4.9 can be obtained from the Python Package Index, or just installed with pip install --upgrade rsa.

This release contains improvements by Arie Bovenberg, Michał Górny, myheroyuki, and myself:

Remove debug logging from rsa/key.py ( #194).
Remove overlapping slots in PrivateKey and PublicKey. ( #189).
Do not include CHANGELOG/LICENSE/README.md in wheel ( #191).
Fixed Key Generation Unittest: Public and Private keys are assigned the wrong way around ( #188).

More information on the Python-RSA page.

Touch pad dimmer with ESP32 & ESPHome

Sun, 05 Jun 2022 22:59:14 +0200

Recently I’ve been toying a lot with ESPHome in combination with Home Assistant. In this post I’ll show how I made a touch-pad LED dimmer.

My goal was to have touch control over one or more LED strips. My requirements for the system:

A single tap should toggle the LED strip. This toggling should use the default transition. In other words, if the the dimming behaviour needs different transitions, this shouldn’t interfere with the normal toggles.
Holding the touch pad should smoothly increase or decrease the brightness the LED strip. This stops when the LED is either fully on or fully off.
Releasing and then holding the touch pad should change the direction, i.e. if the light was getting dimmer, release & hold should start making it brighter.

From a coding standpoint, I had two more wishes:

To add another touch pad + LED strip, it should require as little code copying as possible.
The amount of lambda in the YAML file should be kept to a minimum.

This is what I came up with. The ingredients you need to make it work in the YAML file are:

A light with its output
A binary_sensor for the touch pad
An esp32_touch: section to enable touch support
And finally the touch_dimmer.zip file you can download at the bottom of this post.

Here is a minimal example YAML file:

esphome:
  name: name-of-your-device

# Add a light and its output:
output:
  - platform: ledc
    id: the_output
    pin: GPIO17

light:
  - platform: monochromatic
    id: the_light
    output: the_output
    name: The LED

# Add a binary touch sensor:
esp32_touch:

binary_sensor:
  - platform: esp32_touch
    id: the_touch_sensor
    pin: GPIO13
    threshold: 550

# Add the touch dimmer itself:
touch_dimmer:
  - id: the_touch_dimmer
    light_id: the_light
    touch_id: the_touch_sensor

# The touch dimming code needs the ESPHome scripting
# component. If your YAML file has no scripts yet,
# just add this dummy.
script:
  - id: dummy
    mode: single
    then:

Finally, download touch_dimmer.zip and extract it next to your YAML file. This should give you this directory structure:

your_project.yaml
touch_dimmer_example.yaml
custom_components/touch_dimmer/__init__.py
custom_components/touch_dimmer/touch_dimmer.h

Download touch_dimmer.zip

Last updated for ESPHome version 2025.10.1.

ESP32, BLE, and the fix of the advertisement issues

Sun, 01 May 2022 12:48:55 +0200

After following a ESP32 + Bluetooth Low Energy (BLE) tutorial, my phone would only connect once to the ESP32. After it disconnected it wouldn’t reconnect. This is how I fixed it.

After a lot of tinkering I found out one thing I didn’t find in any of the tutorials I browsed through: after a BLE client connects, the BLE server will stop advertising. As a result, nRF Connect (the app I use to test on my phone) wouldn’t reconnect.

I solved it by restarting the advertising in the onConnect callback function:

class BLEServerCB : public BLEServerCallbacks {
  void onConnect(BLEServer *pServer, esp_ble_gatts_cb_param_t *param) override {
    BLEDevice::startAdvertising();
  }
} bleServerCB;

void setup() {
  BLEDevice::init(DEVICE_NAME);
  BLEServer *bleServer = BLEDevice::createServer();
  bleServer->setCallbacks(&bleServerCB);
  // ... the rest of the setup.
}

This will keep your ESP32 announcing its presence to the world, regardless of who connected in the past. Might not be what you want, but it sure helped me test things.

Flatterer v1.2 released

Wed, 06 Apr 2022 22:12:03 +0200

Flatterer v1.2 has just been released! It gives you the ability to export wire edges and include a table of shape dimensions. Furthermore, it exports to layers compatible with Inkscape, and uses a slightly thicker outline for better visibility in larger projects.

Check Out Flatterer

Flatterer turns a 3D model in Blender into a set of shapes suitable for laser cutting. It’s aimed at easily exporting boxes, enclosures, and other made-for-laser-cutting designs to SVG.

Of course the add-on automatically applies kerf compensation, so there is no need to manually move edges around. For the full list of features check the Flatterer software page.

Flatterer v1.1 released

Sun, 09 Jan 2022 15:06:01 +0100

Flatterer v1.1 has just been released! It gives you more control over the shape packing options. In the past weeks I’ve already had a project for which the default options didn’t quite work well enough, so I decided to expose a few options to give you more control over it.

Sorting: The packing algorithm tries to fit each shape as well as possible. It does this basically shape by shape, and thus the order in which the shapes are packed has an impact on the result. This option allows you to choose this sorting. The choices are:

Do not sort. Not sure what the use is, but you never know.
Sort by descending area.
Sort by descending perimeter. This was the old hard-coded behaviour, and still is the default.
Sort by difference of rectangle sides.
Sort by shortest side.
Sort by longest side.
Sort by ration between sides.

Rotation: The packing algorithm can rotate each shape by 90° to see if that works better. If you don’t want this, you can now turn it off.

Check Out Flatterer

Flatterer turns a 3D model in Blender into a set of shapes suitable for laser cutting. It’s aimed at easily exporting boxes, enclosures, and other made-for-laser-cutting designs to SVG.

Of course the add-on automatically applies kerf compensation, so there is no need to manually move edges around. For the full list of features check the Flatterer software page.

Flatterer: a new Blender add-on

Sun, 09 Jan 2022 15:06:01 +0100

I bought a laser cutter, and of course I want to use Blender to make cuttable designs. So, I made my own add-on called Flatterer.

Flatterer turns a 3D model in Blender into a set of shapes suitable for laser cutting. It’s aimed at easily exporting boxes, enclosures, and other made-for-laser-cutting designs to SVG.

Check Out Flatterer

Of course the add-on automatically applies kerf compensation, so there is no need to manually move edges around. For the full list of features check the Flatterer software page.

Class D Amplifier Prototype

Fri, 10 Dec 2021 13:43:44 +0100

The amplifier we use for the TV is getting old, and an annoying 50 Hz hum is finding its way to the speakers. So, of course, I decided to make my own amplifier. I’ve done that before, with a class B design, and this time I wanted to do something different.

The Class D Simple Amp

This amplifier is a Class D design, which means that it transforms the audio signal into a high-speed (200 kHz) digital signal. It then amplifies that digital signal; because of the digital nature, the amplifier MOSFETs will be either fully on or fully off. Since either no current is flowing (100% off) or the MOSFET has practically no resistance (100% on), there is very little heat produced, making the design energy-efficient.

Circuit diagram of the Class D Simple Amp

This is just a prototype that outputs mono audio. It’s there for me to learn about its behaviour (it’s different on a PCB compared to the earlier breadboard prototype I made) before I copy-paste the components to the final 2.1 (stereo + subwoofer) version.

Above you see the circuit diagram. I’ve shared the design under the GPL license, including the PCB layout, on Open Source Hardware Lab.

Python-RSA 4.8 released

Wed, 24 Nov 2021 11:14:56 +0100

The final release of Python-RSA v4.8 can be obtained from the Python Package Index, or just installed with pip install --upgrade rsa.

This release contains improvements by Ram Rachum, Andrey Semakin, Hubert Kario, Kian Meng Ang, and myself of course:

Switch to Poetry for dependency and release management.
Compatibility with Python 3.10.
Chain exceptions using raise new_exception from old_exception ( #157)
Added marker file for PEP 561. This will allow type checking tools in dependent projects to use type annotations from Python-RSA ( #136).
Use the Chinese Remainder Theorem when decrypting with a private key. This makes decryption 2-4x faster ( #163).

More information on the Python-RSA page.

Light Intensity Tool

Sun, 14 Nov 2021 13:26:26 +0100

For my electronics projects I often have the need to take the linear position of a potentiometer, and translate it to an exponential value I can use to PWM some LEDs. I had some Python scripts scattered around to do this, but figured it was more convenient to have a web-based tool instead. So, here it is!

Go To The Tool

The tool takes the number of bits you can use to PWM the LEDs, and the number of steps you want in the lookup table. It’ll then generate some C code that’ll give you that lookup table.

Fish & Gits

Thu, 14 Oct 2021 15:59:20 +0200

I’ve been using the Fish shell for a while, and it’s really gotten to the point where I miss it when I can’t use it :)

To share with folks, here are some of my Fish configurations and Git configs that make my life as a Blender developer easier.

This post was made possible by the Blender Development Fund.

Fish Config

Update 2024-04-03: I’ve started to track the pull request related functions my projects.blender.org profile space. Go there to get the latest versions.

These I store in ~/.config/fish/conf.d/aliases.fish:

set BLENDER_BUILD_ROOT  /home/sybren/workspace/blender-git
set FLAMENCO_ROOT /home/sybren/workspace/blender/flamenco-3

function cdf -d "CD to Flamenco directory"
    cd $FLAMENCO_ROOT
end

function cdlibs -d "CD to Blender libs directory"
    cd $BLENDER_BUILD_ROOT/lib
end

function cddeps -d "CD to Blender deps directory"
    cd $BLENDER_BUILD_ROOT/build_deps/deps
end

function cdbuild -d "CD to Blender release build directory"
    cd $BLENDER_BUILD_ROOT/build_linux
end

function cddebug -d "CD to Blender debug build directory"
    cd $BLENDER_BUILD_ROOT/build_debug
end

function cdsrc -d "CD to Blender source directory"
    cd $BLENDER_BUILD_ROOT/blender
end

function cdtracker -d "CD to Blender bug tracker directory"
    cd $BLENDER_BUILD_ROOT/tracker
end

function cddocs -d "CD to Blender developer docs and activate the venv"
    cd $BLENDER_BUILD_ROOT/developer-docs
    . ./.venv/bin/activate.fish
end

function cdmanual -d "CD to Blender manual and activate the venv"
    cd $BLENDER_BUILD_ROOT/manual
    . ./.venv/bin/activate.fish
end

function _makebranch -a BRANCH
    cdsrc; or return 1
    printf "\033[95mChecking out branch \033[96m$BRANCH\033[0m\n"
    git co $BRANCH; or return 2
    printf "\033[95mPulling branch \033[96m$BRANCH\033[0m\n"
    git pull; or return 5
    printf "\033[95mmake update\033[0m\n"
    make update; or return 3
    printf "\033[95mBuilding Blender\033[0m\n"
    bb; or return 4
    printf "\033[95mBuilt $BRANCH\033[0m\n"
end

function mm -d "Make Main, update & build Blender main branch, release mode"
    _makebranch main
end

function mmb -d "Make Main, then run Blender"
    _makebranch main; and blender --open-last $argv
end

function mr -d "Make release branch"
    cdsrc
    set branch (git branch -r --list 'origin/blender-v*-release' | sort -n | tail -n 1 | sed 's+.*origin/++')
    printf "\033[95mSwitching to release branch\033[0m \033[96m$branch\033[0m\n"
    _makebranch $branch
end

function bb -d "Build Blender, release mode"
    nice -n 1 ninja -C $BLENDER_BUILD_ROOT/build_linux/ $argv; or return $status
    nice -n 1 ninja -C $BLENDER_BUILD_ROOT/build_linux/ install
end

function bbb -d "Build Blender and run with last file"
    bb && blender --open-last $argv
end

function bbd -d "Build Blender, debug mode"
    nice -n 1 ninja -C $BLENDER_BUILD_ROOT/build_debug/ $argv; or return $status
    nice -n 1 ninja -C $BLENDER_BUILD_ROOT/build_debug/ install
end

function bbbd -d "Build Blender in Debug mode and run with last file"
    bbd && blenderdebug --open-last $argv
end

function bbt -d "Build Blender, Clang-Tidy mode"
    nice -n 1 ninja -C $BLENDER_BUILD_ROOT/build_tidy/ $argv
end

function bbr -d "Build Blender, release branch"
    nice -n 1 ninja -C $BLENDER_BUILD_ROOT/build_release/ $argv
end

function cdb
    set BLENDVER (blender --version | grep '^Blender' | cut -d' ' -f2 | sed 's/\\([0-9]\\+\\.[0-9]\\+\\).*/\\1/')
    echo "Blender version: $BLENDVER"
    cd ~/.config/blender/$BLENDVER
end

function git_rebase_onto_main
    read -P "Rebase onto main? ENTER for yes, CTRL+C for no."; or begin
        printf "\033[94mNot rebasing, the work is done.\033[0m\n"
        return
    end
    git rebase main; and git submodule foreach git pull --rebase origin main
end

function svnadd -a SUBDIR -d "Add new files and remove deleted files"
  # This is the Fish way of doing `SVN_STATUS=$(<svn status $SUBDIR)`
  begin; set -l IFS; set SVN_STATUS (svn status $SUBDIR); end

  echo "$SVN_STATUS" | grep '^\? ' | sed 's/^.//' | xargs --no-run-if-empty -n 1 svn add
  echo "$SVN_STATUS" | grep '^\! ' | sed 's/^.//' | xargs --no-run-if-empty -n 1 svn rm
end

function pr -d "Pull in a Blender pull request"
    # Set defaults
    set _flag_owner blender
    set _flag_repo blender

    argparse 'o/owner=' 'r/repo=' -- $argv
    or return 48

    # Check for -r owner/repo notation:
    set _flag_combined (echo "$_flag_repo" | string split /)
    set _num_combined (count $_flag_combined)
    if [ $_num_combined -gt 1 ]
        set _flag_owner $_flag_combined[1]
        set _flag_repo $_flag_combined[2]
    end

    set PRNUM $argv[1]

    set JSON "pr-$PRNUM.json"
    set URL "https://projects.blender.org/api/v1/repos/$_flag_owner/$_flag_repo/pulls/$PRNUM"
    if ! curl --fail --no-progress-meter -o$JSON $URL
        printf "\033[91mError fetching $URL\033[0m\n"
        return 49
    end

    # Sanity check we can read the result
    if ! jq <$JSON >/dev/null
        printf "\033[91mCannot parse JSON at $JSON\033[0m\n" >&2
        return 50
    end

    set PR_STATUS (jq -r .state <$JSON)
    if [ (jq -r .merged <$JSON) = "true" ]
        printf "\033[92mPR is already merged, check $URL\033[0m\n"
        echo "Merged at:" (jq -r .merged_at <$JSON)
        echo "Merged by:" (jq -r .merged_by.full_name <$JSON)
        return 51
    end
    if [ (jq -r .state <$JSON) = "closed" ]
        printf "\033[91mPR is closed, check $URL\033[0m\n"
        return 50
    end

    set PR_NUM (jq -r .number <$JSON)
    set PR_TITLE (jq -r .title <$JSON)
    printf "\033[95mPulling #$PR_NUM: $PR_TITLE\033[0m\n"

    set PR_REPO (jq -r .head.repo.full_name <$JSON)   # "ChrisLend/blender"
    set PR_AUTHOR (jq -r .head.repo.owner.username <$JSON)   # "ChrisLend"
    set PR_BRANCH (jq -r .head.ref <$JSON) # "vertical_scrolling_offscreen"
    set PR_BASE_BRANCH (jq -r .base.ref <$JSON) # "main" or "blender-v3.5-release"
    set LOCAL_BRANCH "PR/$PRNUM/$PR_AUTHOR-$PR_BRANCH"

    printf "\033[90mIncoming branch: $PR_REPO\033[0m\n"
    printf "\033[90mBase  branch   : $PR_BASE_BRANCH\033[0m\n"
    printf "\033[90mLocal branch   : $LOCAL_BRANCH\033[0m\n"

    rm -f $JSON

    set CURBRANCH (git branch --show-current 2>/dev/null)
    if test "$CURBRANCH" != "$PR_BASE_BRANCH";
        git checkout $PR_BASE_BRANCH
    end
    if git branch | grep -q $LOCAL_BRANCH;
        printf "\033[95mBranch $LOCAL_BRANCH exists, going to refresh it\033[0m\n"
        git branch -D $LOCAL_BRANCH
    else
        printf "\033[96mBranch $LOCAL_BRANCH does not exist\033[0m\n"
    end

    git checkout -b $LOCAL_BRANCH $PR_BASE_BRANCH; or return 47
    git pull --no-rebase --ff --no-edit --commit https://projects.blender.org/$PR_REPO $PR_BRANCH; or return 48

    printf "\033[95mBranch $LOCAL_BRANCH is ready for use\033[0m\n"
    printf "\033[94mPulled #$PR_NUM: $PR_TITLE\033[0m\n"
end

function prprune -d "Delete all PR/* branches"
    set BRANCHES (string trim (git branch | grep '^  PR/'))
    if test -z "$BRANCHES";
        echo "No PR branches to prune"
        return 0
    end
    git branch -D $BRANCHES
end

function ffmp4 -a FNAME -d "Use FFmpeg to convert MKV to MP4"
    set OUTNAME (string replace -i .mkv .mp4 "$FNAME")
    if test "$FNAME" = "$OUTNAME";
        set OUTNAME (string replace -i -- .mov .mp4 "$FNAME")
    end
    if test "$FNAME" = "$OUTNAME";
        set OUTNAME (string replace -i -- .webm .mp4 "$FNAME")
    end
    if test "$FNAME" = "$OUTNAME";
        set OUTNAME (string replace -i -- .mp4 -recoded.mp4 "$FNAME")
    end
    if test "$FNAME" = "$OUTNAME";
        echo "Input must end in .mkv, .mp4, .webm, or .mov"
        return 1
    end

    ffmpeg -i "$FNAME" -c:v h264 -crf 23 -c:a aac -b:a 192k "$OUTNAME"
    or return $status

    dolphin --select "$OUTNAME" & disown
end

alias l='ls -F --color=auto'
alias ll='l -lh'
alias df='df -h'
alias du='du -h'
alias grep='grep --color'
alias qtc='qtcreator -client'
alias sqlite='sqlite3'
alias docker-logfile='docker inspect --format="{{.LogPath}}"'
alias json_pp="python3 -c 'import json, sys; print(json.dumps(json.load(sys.stdin), sort_keys=True, indent=4))'"
alias trimlong="sed 's/\(.\{120\}\).*/\1…/'"
alias ffprobe-json="ffprobe -v error -hide_banner -print_format json -show_streams -show_format"
alias dot2png="dot -Tpng -O"
alias abccat="abcls -a -m -l -r -t"
alias cdp="cd (pwd -P)"
alias bcode="code $BLENDER_BUILD_ROOT/blender.code-workspace"
alias dcode="cddocs; code ."
alias wg='wget --content-disposition'

alias rbi="git rebase --interactive"
alias rbc="git rebase --continue"
alias rba="git rebase --abort"
alias gg="git gui"
alias gga="git gui citool --amend"

Git Config

My Git configuration (~/.gitconfig) also has some nice aliases & other options:

[color]
    ui = auto
[pull]
    rebase = true
[push]
    default = simple
[alias]
    co = "checkout"
    cp = "cherry-pick"
    ff = "merge --ff-only"
    mt = "mergetool"
    up = "checkout @~1"
    st = "status --ignore-submodules=none"
    car = "commit --amend --reset-author"
    rbi = "rebase -i"
    rbc = "rebase --continue"
    rba = "rebase --abort"
    tpush = "!git push && git push --tags"
    out = "log @{u}.. --pretty=oneline"
    head = "show HEAD"
    unstash = "stash pop"
    authors = "!f() { git log --since 'now - 1 year' \"$@\" | grep ^Author | sed 's/Author: //' | sed 's/<.*>//' | sort -f | uniq -ci | sort -nr | nl -s '' | sort -nr; } ; f"
    glog = "log --all --graph --abbrev-commit --decorate --date=short --format=format:'%C(bold blue)%h%C(reset) %C(green)(%ad)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(dim magenta)%d%C(reset)'"
    onelog = "log --abbrev-commit --decorate --date=short --format=format:'%C(bold blue)%h%C(reset) %C(green)(%ad)%C(reset) %C(white)%s%C(reset) %C(dim white)- %an%C(reset)%C(dim magenta)%d%C(reset)'"
    ver = "log --oneline -n 1 --no-abbrev"
[diff]
    tool = kdiff3
    guitool = kdiff3
[merge]
    tool = kdiff3
    guitool = kdiff3
  	renamelimit = 4096
[core]
    excludesfile = /home/sybren/.configfiles/gitignore_global
[gui]
    gcwarning = false
    encoding = utf-8
[rerere]
  	enabled = true
[gc]
  	rerereUnresolved = 365
  	rerereResolved = 365

BeatStripper v7 released

Sun, 19 Sep 2021 10:55:57 +0200

This release of Beat Stripper is compatible with Beat Saber version 1.17. Furthermore, it now auto-capitalises the player names in the party mode name picker (the one you see after you finish a map).

BeatStripper strips down party mode scores to just each player’s highest score. It can also merge Solo scores into the Party leaderboards.

Get BeatStripper

Read more about how to use it on my BeatStripper page.

Spherical Panoramas Explained

Sun, 29 Aug 2021 12:48:25 +0200

Want to create beautiful spherical panoramas? Check out the new article I wrote on the subject: Spherical Panoramas. It covers:

The required hardware.
How to shoot the photos.
Editing the photos.
Using Hugin to stitch them together & do HDR-merging.
Viewing your result.

What are you waiting for? Go and read the article!

Skyfill v1.5 released

Sun, 25 Jul 2021 15:42:23 +0200

Version v1.5 of Skyfill has been released. The most important improvement is the addition of a mirror ball mode. The mirror ball reflects the ground, resulting in a mini planet version of the panorama hanging in the sky. To see what it looks like, check these tulip fields and be sure to look up.

Apart from the mirror ball, performance has been improved, so even normal Sky-filling will be faster.

Get Skyfill

You can grab your copy at Gitlab, and read how to use the mirror ball feature in the documentation

Most drones (UAVs) cannot look straight up to photograph the sky above them. As a result, spherical panoramas made with drones tend to have a gap in the sky. Some drones, like my DJI Mavic 2, can fill in this gap automatically while generating a preview. However, when I stitch the photos myself to get a better quality output, there is still that sky gap. I got fed up with having to choose between a nice sky or a nice overall image, so I did what developers do and made my own software: Skyfill.

Code in MarkDown

Sun, 11 Jul 2021 12:15:07 +0200

Many systems like Discord, Matrix, Blender Chat, Stack Exchange, Discourse, Slack, etc. use MarkDown for their markup. In short, this allows you to share snippets of code with each other. The thing that makes this worth writing about, is that natural text should behave differently from code. Natural text can be rewrapped to comfortably match the device you’re reading it on. With code, however, this should not be done, as it makes it horrible to read.

Whatever you do, do not post a screenshot of your code. It may look like the simple solution, but it’s only simple for you. It’s impossible to copy-paste code from a screenshot into a text editor, so if someone wants to help you out by adjusting your code for you, you’ve now forced them into typing it all by hand.

The solution is that you have to mark blocks of code with triple backticks. On many keyboards this is one of the left-most keys, left of the 1, under the Escape key. This is what it looks like:

```
def function():
    print("This is just some code")
```

The above will look like this:

def function():
    print("This is just some code")

If you want to get syntax highlighting as well, be sure to type the language name directly after the opening backticks, like this:

```python
def function():
    print("This is just some code")
```

def function():
    print("This is just some code")

This is not always supported by all MarkDown systems, though. For example, Phabricator, Blender’s previous bug tracker, used lang=python as marker, instead of just python. Gitea, Blender’s current bug tracker works just fine with the python marker, and also supports cpp for C++, diff for diffs, and many more.

BeatStripper v6.0 released

Sat, 08 May 2021 23:10:15 +0200

This release of Beat Stripper is compatible with the newly released Beat Saber 1.15, the three-year celebratory release. Congratulations BeatSaber!

The compatibility check with newer versions of Beat Saber became much smarter. The file’s contents are now checked, and not just the version number. This makes BeatStripper forward compatible with new versions, until they actually change what’s saved in the files. Previously they bumped the version number but kept the contents the same, which was a bit annoying. Now BeatStripper is compatible with the future!

BeatStripper strips down party mode scores to just each player’s highest score. It can also merge Solo scores into the Party leaderboards.

Download the latest release

Read more about how to use it on my BeatStripper page.

Adding support for ATmega328PB to AVR-GCC and AVRDude

Tue, 27 Apr 2021 12:14:12 +0200

Update (2025-05-15): Nowadays I would recommend PlatformIO when writing software for the ATmega328PB microcontroller. It has built-in support for the PB variant, and has worked like a charm in my latest project.

AVR-GCC 10 only has partial support for the ATmega328PB microcontroller. For some reason, it does have a “device spec” file but misses other essential files. In this post I’ll explain how to rectify that.

Note that the ATmega328PB was introduced in 2016, and GCC 10.3 was released in 2021. Not sure why GCC does have support for the ATmega328P but not its improved (and 5 years old already) brother ATmega328PB.

I’m developing most of my microcontroller code on Windows, but with some GNU-style tools (like Git-Bash), hence the mixture of forward and backward slashes in paths. All of this should be independent of which platform you actually develop on, though.

Update 2021-05-04: This approach also works for the ATmega168PB microcontroller.

Update 2021-05-09: I zipped the files together into atmega-168pb-328pb-for-avr-gcc-10.1.0.zip. Extract that to the root of your GCC install. After that, you only need to edit avr\include\avr\io.h as described below in the 2nd step.

The problem

# From the C:\avr-gcc-10.1.0-x64-windows directory:
$ find -name '*328p*'
./avr/include/avr/iom328p.h
./avr/lib/avr5/crtatmega328p.o
./avr/lib/avr5/libatmega328p.a
./lib/gcc/avr/10.1.0/device-specs/specs-atmega328p
./lib/gcc/avr/10.1.0/device-specs/specs-atmega328pb

As you can see, there are a bunch of files for the ATmega328P that are missing for the ATmega328PB.

Fixing AVR-GCC

Fixing GCC requires two steps: copying some files, and patching a header file.

1. Copying the files

You can get the files from the ATmega DFP support pack from Microchip’s website, or from your install of Microchip Studio.

From the ATmega DFP Support Pack

Download the ATmega DFP support pack
Unzip the relevant files: unzip -j Atmel.ATmega_DFP.x.y.zzz.atpack
gcc/dev/atmega328pb/avr5/crtatmega328pb.o
gcc/dev/atmega328pb/avr5/libatmega328pb.a
include/avr/iom328pb.h
Place the .o and .a files C:\avr-gcc-10.1.0-x64-windows\avr\lib\avr5\ (so next to their 328P counterparts).
Place the .h file in C:\avr-gcc-10.1.0-x64-windows\avr\include\avr\
Continue with the ‘Common Last Step’ below

From Microchip Studio

Use this if you have Microchip Studio with the ATmega DFP support pack already installed.

Find the DSP at C:\Program Files\Microchip\xc8\vX.YY\dfp\xc8\avr
From lib\avr5, copy crtatmega328pb.o and libatmega328pb.a to C:\avr-gcc-10.1.0-x64-windows\avr\lib\avr5\.
Copy include\avr\iom328pb.h to C:\avr-gcc-10.1.0-x64-windows\avr\include\avr\
Continue with the ‘Common Last Step’ below

2. Patching io.h

Add the following to C:\avr-gcc-10.1.0-x64-windows\avr\include\avr\io.h just underneath the part that handles the ATmega328P.

#elif defined (__AVR_ATmega328PB__)
#  include <avr/iom328pb.h>

You should now be able to use avr-gcc -mmcu=atmega328pb and avr-g++ -mmcu=atmega328pb to compile C and C++ sources for the ATmega328PB chip.

Fixing AVRDude

To actually program the ATmega328PB with AVRDude, you need to update its configuration avrdude.conf. You can find the file in c:\avr-gcc-10.1.0-x64-windows\bin\avrdude.conf or in /etc/avrdude.conf on Linux.

Add this below the ATmega328P definition:

part parent "m328"
    id          = "m328pb";
    desc        = "ATmega328PB";
    signature   = 0x1e 0x95 0x16;

    ocdrev      = 1;
;

Setting up Microchip Studio

To configure Microchip Studio to use this new GCC, you have to add a Toolchain Flavour:

Go to the project properties, “Advanced” tab, and there follow the link to the preferences.
Add a new flavour for both the Atmel AVR 8-bit (C Language) and Atmel AVR 8-bit (CPP language) toolchains. Name it whatever you want, and point it to the bin directory of your GCC install.
Press OK, and select the new toolchain flavour from the drop-down select box.

Credits

This post was adapted from Gonçalo Ribeiro’s gist. I decided to change some things around to match my own development environment. Also having it as part of my blog makes it easier to find for whenever I need to repeat this trick.

BeatStripper v5.0 released

Fri, 19 Mar 2021 09:53:31 +0100

This release of Beat Stripper is compatible with the newly released Beat Saber 1.14 (new OST, yay!).

Show how many solo scores you improved since the last run. Requires running with the -solo CLI option.
Skip saving files when there was nothing for BeatStripper to do.
Support file format 2.0.16, introduced by BeatSaber version 1.14.0.

BeatStripper strips down party mode scores to just each player’s highest score. It can also merge Solo scores into the Party leaderboards.

Download the latest release

Read more about how to use it on my BeatStripper page.

BeatStripper v4.2 for BeatSaber 1.13.4

Tue, 09 Mar 2021 21:39:21 +0100

This release of Beat Stripper is compatible with the newly released Beat Saber 1.13.4.

BeatStripper strips down party mode scores to just each player’s highest score. It can also merge Solo scores into the Party leaderboards.

~~There was an issue with this release, so I removed it from the releases page. Hold on, I’m working on a fix.~~

There was no issue with this release, just a misunderstanding. Version 4.2 is good to go!

Download the latest release

Read more about how to use it on my BeatStripper page.

BeatZipper v2.0 released

Fri, 05 Mar 2021 23:58:05 +0100

Beat Savior is a great site to download custom Beat Saber maps, most of all because you can watch a preview of the level on their website. This makes it really convenient to browse, check, and download the maps.

The biggest gripe I have is that after downloading you have to manually install each map, by creating a directory and unzipping the downloaded file. Yes, there are other ways, but this manual approach makes it possible for me to do this while waiting for, say, some software I’m working on to compile.

So, of course, I automated the process and created BeatZipper.

This version adds a nicer interface, and is simpler to use.

Download the latest release

Check the BeatZipper page for instructions on how to use it.

BeatStripper v4.0 released

Tue, 02 Mar 2021 21:14:14 +0100

This release of Beat Stripper fixes an issue with including Solo scores in Beat Saber’s Party Mode leaderboards, and adds experimental support for Linux.

Some new commandline arguments have also been added, but they’re mostly useful for me as a developer.

Set up a shortcut that runs beatstripper.exe -solo, run it, and it’ll copy your solo scores into party mode.

First time you run it you’ll have to give your name. This will get “(solo)” appended to it, so typing the name “Sybren” will result in “Sybren (solo)” in the Party Mode leaderboards.

Download the latest release

Read more about how to use it on my BeatStripper page.

BeatStripper v3.0 released

Wed, 17 Feb 2021 21:06:04 +0100

Include your Solo scores in Beat Saber’s Party Mode leaderboards.

Have you ever wanted to know what score you got in Solo mode, while actually playing in Party Mode? This version of Beat Stripper adds an experimental feature that makes this possible.

Set up a shortcut that runs beatstripper.exe -solo, run it, and it’ll copy your solo scores into party mode.

First time you run it you’ll have to give your name. This will get “(solo)” appended to it, so typing the name “Sybren” will result in “Sybren (solo)” in the Party Mode leaderboards.

Download the latest release

Read more about how to use it on my BeatStripper page.

BeatStripper v2.0 released

Sun, 24 Jan 2021 14:56:16 +0100

Beat Saber is a great party game, but I have one gripe with the way it handles party high scores. It stores the last 10 high scores of each song, regardless of who obtained those scores. So, I made a little program to clean them up and only keep one high score per player.

Download the latest release

Read more about how to use it on my BeatStripper page.

Thanks to Muesli for pointing me to the BubbleTea framework, which I used to create the Text User Interface for BeatStripper.

MyPy and Blender

Fri, 15 Jan 2021 16:24:18 +0100

MyPy is a fantastic tool to do static checks of Python code. To make it work well with Blender, there are some tweaks to make to its configuration.

This is the config that I use. You can place it in a pyproject.toml file, or in mypy.ini, whatever you wish.

[mypy]
python_version = 3.7
ignore_missing_imports = True
strict_optional = True
disallow_subclassing_any = False
disallow_any_generics = True
disallow_untyped_calls = True
disallow_incomplete_defs = True
check_untyped_defs = True
disallow_untyped_decorators = True
no_implicit_optional = True
warn_redundant_casts = True
warn_unused_ignores = true
warn_return_any = True

This enforces that a typed function (so one that declares at least one parameter or its return type) only calls into other typed functions. I’ve made mistakes in the past where MyPy ignored an untyped function; the lack of errors made me think incorrectly that the code was ok.

The only thing that MyPy doesn’t like is the way Blender declares properties, for example in operators and property groups. To work around this, use a # type: ignore marker, like this:

from bpy.props import BoolProperty, PropertyGroup
class MyAddonSettings(PropertyGroup):
    enable_feature : BoolProperty(      # type: ignore
        name = "Enable The Feature",
        description = "Turn on this amazing thing and be amazed",
    )

With all of this in place, you can run mypy my_addon.py (for single-file addons) or mypy my_addon (where my_addon is the directory containing the Python sources).

Python-RSA 4.7 released!

Sun, 10 Jan 2021 11:47:18 +0100

The final release of Python-RSA v4.7 can be obtained from the Python Package Index, or just installed with pip install --upgrade rsa.

This release contains improvements by hugovk, tomato42, and myself of course:

Declare & test support for Python 3.9.
CVE-2020-25658 - Bleichenbacher-style timing oracle in PKCS#1 v1.5 decryption code (Fixes #165).
Add padding length check as described by PKCS#1 v1.5 (Fixes #164).
Reuse of blinding factors to speed up blinding operations (Fixes #162).

More information on the Python-RSA page.

Locally re-pulling a Blender patch

Fri, 08 Jan 2021 11:20:46 +0100

As core developer of Blender I often review patches from colleagues and other contributors. Getting that patch on my local machine is as easy as typing arc patch D1234, where D1234 is the patch number. Once the author of the patch has updated it according to the feedback of the reviewers, it’s not as trivial to update my local copy of the patch, though. This involves:

git checkout master
git branch -D arcpatch-D1234
arc patch D1234

Without deleting the branch, Arcanist will, instead of updating the existing one, make a new branch for the patch.

So, as usual, I wrote a little Fish shell script to do this work for me. Fish shell? Yeah. After I posted my ZSH configuration, a friend of mine pointed me to the Fish shell. It took a bit of getting used to, but now I’m hooked, and I use it wherever I can. I might write another blog post about that some time.

UPDATE (2021-02-01): I’ve added optional rebasing on top of master to the commands. Just press ENTER to rebase, or Ctrl+C to skip that step and keep the branch as-is.

function git_rebase_onto_master
    read -P "Rebase onto master? ENTER for yes, CTRL+C for no."
    git rebase master && git submodule foreach git pull --rebase origin master
end

function arcpull -d "Refresh and reapply the current patch from Phabricator"
    set BRANCH (git branch --show-current 2>/dev/null)
    if [ -z "$BRANCH" ];
        echo "Not on a Git repo"
        return 42
    end

    set PATCHNUM (string replace arcpatch-D '' $BRANCH)
    if [ $BRANCH = $PATCHNUM ];
        echo "Current branch $BRANCH is not an arcpatch branch" >&2
        return 47
    end
    echo "Current branch $BRANCH is for patch $PATCHNUM"

    git checkout master
    git branch -D $BRANCH
    arc patch D$PATCHNUM
    git_rebase_onto_master
end

Now all I have to do is type arcpull and it’ll figure out which patch the current branch is for, and get a fresh copy for me.

UPDATE: I’ve added another command to the script: arcpatch D1234. This nukes the arcpatch-D1234 branch if you have it, and re-fetches the patch. It’s basically a version of the script above, except that it doesn’t take the D-number from the current branch but from the CLI argument.

function arcpatch -a PATCHNAME -d "Apply a patch from Phabricator"
    if test -z "$PATCHNAME";
        echo "Usage: arcpatch D1234" >&2
        return 47
    end

    set BRANCH arcpatch-$PATCHNAME

    set CURBRANCH (git branch --show-current 2>/dev/null)
    if test "$CURBRANCH" != "master";
        git checkout master
    end

    if git branch | grep -q $BRANCH;
        printf "\033[95mBranch $BRANCH exists, going to refresh it\033[0m\n"
        git branch -D $BRANCH
    else
        printf "\033[96mBranch $BRANCH does not exist\033[0m\n"
    end
    arc patch $PATCHNAME
    git_rebase_onto_master
end

UPDATE 2: another command to simply remove all arcpatch-Dxxxx branches:

function arcprune -d "Delete all arcpatch-Dxxxx branches"
    set BRANCHES (string trim (git branch | grep arcpatch-D))
    if test -z "$BRANCHES";
        echo "No arc branches to prune"
        return 0
    end
    echo git branch -D $BRANCHES
end

This post was made possible by the Blender Development Fund.

Toggle Blender's Build Options

Mon, 07 Dec 2020 13:11:51 +0100

My work on Blender mostly involves the Animation & Rigging module. For this, I can do without Cycles, USD, Alembic, Collada, and some other modules. Disabling those modules allows me to build Blender faster. It would be even faster to disable everything you can disable, but that would disable way too much. Also, it’s hard to change it back, because you can’t just enable everything either.

So, as usual, I wrote a little script to do this for me. Save the script below to your build directory, and name it enable-stuff.sh. Then create a symlink ln -s enable-stuff.sh disable-stuff.sh.

#!/bin/bash

MY_BASE=$(basename "$0")
MY_DIR=$(dirname $(readlink -f $0))

case $MY_BASE in
    enable-stuff.sh)
        WITH=ON
        ;;
    disable-stuff.sh)
        WITH=OFF
        ;;
    *)
        echo "Unknown name $MY_BASE" >&2
        exit 47
        ;;
esac

set -ex
cd $MY_DIR
cmake \
    -DWITH_ALEMBIC=${WITH} \
    -DWITH_OPENCOLLADA=${WITH} \
    -DWITH_USD=${WITH} \
    -DWITH_CODEC_AVI=${WITH} \
    -DWITH_CYCLES=${WITH} \
    -DWITH_LIBMV=${WITH} \
    -DWITH_MOD_FLUID=${WITH} \
    -DWITH_MOD_OCEANSIM=${WITH} \
    -DWITH_MOD_REMESH=${WITH} \
    .
nice -n 20 ninja -C $MY_DIR

I made a similar script for enabling and disabling tests, which only sets the WITH_GTESTS build option. I’ll leave that as an exercise for the reader.

This post was made possible by the Blender Development Fund.

BeatZipper

Sat, 05 Dec 2020 21:20:54 +0100

So, of course, I automated the process and created BeatZipper.

Download the latest release

Check the BeatZipper page for instructions on how to use it.

PWM and Visual Brightness

Wed, 02 Dec 2020 11:58:34 +0100

UPDATE: I’ve made an online version of the script too. So if you just want to get the values, go there & use it directly in your browser.

For my microcontroller projects I often want to convert some linear value (like a potentiometer position) into a light intensity. Since our eyes aren’t linear, this requires some math, and generally microcontrollers aren’t that good in math.

Our eyes roughly experience a doubling of the amount of light as a single “step”. Double it again, and we perceive it as a similarly-sized step. This means that, for our eyes to perceve the light becoming brighter linearly, it actually needs do that exponentially.

10-bit Power levels produced by my script. The linear start is hard to see, but it helps in controlling the light.

My microcontrollers use either a 10-bit or 8-bit value to contol the brightness. This provides a bit of a technical hurdle, because the exponential growth of the light’s brightness actually starts out really slow. Converting that slow start to a sequence of integers would produce a sequence like 0 0 0 1 1 2 3 5. Those repeated numbers mean that whatever you use to control the light (like up/down buttons) will appear to do nothing at first. To prevent this, my script will simply start with linearly increasing numbers, like 0 1 2 3 4 5, before moving on to an exponential slope.

Using the script

UPDATE: I’ve made an online version of the script too. So if you just want to get the values, go there & use it directly in your browser.

The script needs Python to run. Download sybrens_light_intensity_script.py, save it, edit it in a text editor to adjust the parameters to your needs, and run it. It will output a few lines of C code that can be used for microcontrollers.

Example 10-bit output

This is what will be printed with the default settings of the script:

10 bit intensity values
30 steps in total
6 linear steps to start with

static const uint16_t light_map_10bit[] = {
    0, 1, 2, 3, 4, 5, 7, 9, 11, 14, 18, 22, 28, 35, 43, 54, 67, 83, 102,
    126, 156, 192, 237, 293, 361, 444, 548, 674, 831, 1023};

Example 8-bit output

This is what will be printed with some modified settings.

8 bit intensity values
30 steps in total
4 linear steps to start with

static const uint8_t light_map_8bit[] = {
    0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 12, 15, 18, 21, 24, 29, 34, 40, 47, 54,
    64, 74, 87, 102, 118, 138, 161, 188, 219, 255};

How I use it

The values in the light map produced by my script are fed to a Pulse Width Modulator. These simply count up until their maximum (1023 for a 10-bit one) and then restart at zero again. When they start counting, they turn on the light, and when they go past a given value, they turn off the light again. The higher the value, the longer the light stays on, and the brighter you see it. This happens all thousands of times per second, so to our eyes the light is stable, even though it’s actually rapidly blinking.

Phabricator Link Copy

Thu, 19 Nov 2020 14:03:58 +0100

Blender developers use Phabricator to track tasks, bug reports, and patches. Often I need to create links to patch reviews, bug reports, etc. I got tired of manually typing those, so I created a little Greasemonkey script.

First download the GreaseMonkey add-on for your browser, then add the script. It should create two buttons in the top bar, “MD” and “WIKI”, for respectively MarkDown and MediaWiki syntax.

This is my 2nd GreaseMonkey script for Phabricator, the first one was to count things in lists.

// ==UserScript==
// @name     Phabricator Document Link
// @version  1
// @include  https://developer.blender.org/*
// @grant    GM.setClipboard
// ==/UserScript==

function add_document_links() {
  let page_name = find_page_name();
  if (page_name === "") return;

  let page_title = find_page_title();
  if (page_title === "") return;

  add_button("MD", "[" + page_name + ": " + page_title + "](" + window.location + ")");
  add_button("MD (short)", "[" + page_name + "](" + window.location + ")");

  if (is_git_commit(page_name)) {
    let commit_id = window.location.pathname.substr(1, 14);
    add_button("WIKI (long)", "{{GitCommit|" + commit_id + "}}: " + page_title);
    add_button("WIKI (short)", "{{GitCommit|" + commit_id + "}}");
  } else {
    add_button("WIKI", "{{Phab|" + page_name + "}}: " + page_title);
  }

  add_button("TXT", page_name + ": " + page_title);
}

function add_button(button_text, clipboard_text) {
  let button = document.createElement('button');
  button.textContent = button_text;
  button.className = 'button button-grey';
  button.setAttribute("title", clipboard_text);
  button.addEventListener('click', function() {
    console.log('Clipboard:', clipboard_text);
    GM.setClipboard(clipboard_text);
  });

  let button_parent_elt = find_button_parent_element();
  button_parent_elt.appendChild(button);
}

function find_button_parent_element() {
  let elements = document.getElementsByClassName('phabricator-main-menu-alerts');
  if (elements.length == 0) return undefined;
  return elements[0];
}

function find_page_name_element() {
  let page_name_elts = document.getElementsByClassName('phui-crumb-name');
  if (page_name_elts.length == 0) return undefined;
  return page_name_elts[page_name_elts.length-1];
}

function find_page_name() {
  let page_name_elt = find_page_name_element();
  if (!page_name_elt) return "";
  return page_name_elt.textContent.trim();
}

function find_page_title() {
  let page_title_elts = document.getElementsByClassName('phui-header-header');
  if (page_title_elts.length == 0) return "";
  let page_title = page_title_elts[0].textContent;
  return page_title.trim();
}

function is_git_commit(page_name) {
  return page_name.length == 12 && /^[0-9A-Fa-f]{12}$/.test(page_name) && window.location.pathname.startsWith("/r")
}

window.setTimeout(add_document_links, 100);

Phabricator List Count

Tue, 29 Sep 2020 11:39:11 +0200

Blender developers use Phabricator to track tasks, bug reports, and patches. Powerful as Phabricator is, when listing the patches that are waiting to be reviewed, it doesn’t give you the total count. Since we have to report those counts, I got tired of manually counting them and created a little Greasemonkey script.

First download the GreaseMonkey add-on for your browser, then add the above script. Any list view should now show the number of items in that list. It also copies the next/previous page buttons to the top of the list, for easy access.

Update: I made another GM script, for copying MarkDown and MediaWiki compatible links from Phabricator.

// ==UserScript==
// @name     Phabricator Table Counts
// @version  1
// @include  https://developer.blender.org/*
// ==/UserScript==

function count_table_rows() {
  let listviews = document.getElementsByClassName('phui-oi-list-view');
  if (listviews.length == 0) {
    return;
  }
  let listview = listviews[0];
  let p = document.createElement('p');
  p.textContent = listview.children.length + " elements in this list.";

  let pagers = document.getElementsByClassName('application-search-pager');
  if (pagers.length > 0) {
    p.textContent += ' There are more pages: ';

    let buttons = pagers[0].getElementsByClassName('button');
    for (i=0; i<buttons.length; i++) {
      let button = buttons.item(i);
      p.appendChild(button);
    }
  }

  listview.parentElement.insertBefore(p, listview);
}

window.setTimeout(count_table_rows, 500);

Skyfill v1.2 released

Sun, 13 Sep 2020 11:53:33 +0200

Version v1.2 of Skyfill has been released. The most important improvements are support for 16-bit colour and AdobeRGB. You can download the release from Gitlab.

The 16-bit colour support is automatic. Feed Skyfill a 16-bit image, and it’ll output a 16-bit TIFF.

The AdobeRGB support is preliminary. It’s not auto-detected from the input file, so you have to run Skyfill with skyfill -adobergb myimage. The output image also won’t declare it’s AdobeRGB, but it will be. If you know of any way to read and write embedded colour space information in Go, please let me know!

These improvements were sponsored by Dan Rose. Thanks, Dan!

Skyfill allows you to do fill in the gap in the sky in high-resolution images.

Comments on Scripting for Artists

Tue, 01 Sep 2020 10:49:07 +0200

During the Corona lockdown, I’ve been extending my Python training series Scripting for Artists with a bunch of free chapters. This has been picked up by Nico Zevallos, who has written down notes from the series on GitHub. Not only that, he also shares the blend files that he made based on the series. Thanks for the work, Nico.

Go to Nico’s GitHub project

The Scripting for Artists training series is available on Blender Cloud, and I made it as part of my work at Blender Institute, funded by Blender Cloud subscribers.

Zwijnenbergerweg

Thu, 13 Aug 2020 23:47:57 +0200

Check this panorama photo on stuvelfoto.nl to see it in its full splendor. Drag in the photo to look around.

This is a panorama that I made for the Dutch Landscape Pack on the HDRI section of Blender Cloud. Over there it’s also available as HDR image for Blender Cloud subscribers.

My ZSH configuration

Wed, 05 Aug 2020 12:21:13 +0200

A while (read: over 4 years) ago I moved from Bash to ZSH, and never looked back. Initially I tried it out because Bash was getting quite slow with its tab completion, and ZSH was considerably faster. After switching, I also noted that ZSH is smarter in other areas. For example, when typing chmod -x {tab}, it’ll only auto-complete with files that are executable. When typing chmod -x file1 {tab} it will even skip file1 because you already used that one.

Another advantage is that you can paste some commands into the shell and it will not execute them until you press Enter. Even when there are newlines in the pasted text, ZSH won’t execute until you actually press the Enter key. This IMO is good for security, but also helps to avoid errors when accidentally pasting the wrong thing.

To get things working juuuust right, I had to tweak some settings. Note that this doesn’t list everything in my ~/.zshrc, just some parts that I think may be of interest to others.

Auto-completion

# The following lines were added by compinstall
zstyle :compinstall filename '/home/sybren/.zshrc'

autoload -Uz compinit
compinit
# End of lines added by compinstall

# Get Git/Mercurial/SVN info in the prompt (current branch, current action, etc.)
autoload -Uz vcs_info
zstyle ':vcs_info:*' enable hg git svn
# Display current HG action (like 'merging')
zstyle ':vcs_info:hg*' get-mq true
zstyle ':vcs_info:*'         formats '%F{5}(%f%s%F{5})%F{3}-%F{5}[%F{2}%b|%m%F{5}]%f'
zstyle ':vcs_info:hg*' actionformats '%F{5}(%f%s|%F{red}%a%F{5})%F{3}-%F{5}[%F{2}%b|%m%F{5}]%f'

precmd () { vcs_info }
export PS1='
%F{2}%n@%m%f %F{3}%~%f ${vcs_info_msg_0_}%E
%# '

# Custom completions
zstyle ":completion:*:*:abcecho:*" file-patterns "*.abc *(-/)"
zstyle ":completion:*:*:abcls:*" file-patterns "*.abc *(-/)"
zstyle ":completion:*:*:abcview:*" file-patterns "*.abc *(-/)"
zstyle ":completion:*:*:usdview:*" file-patterns "*.usd[ac] *.usd *.abc *(-/)"
zstyle ":completion:*:*:usdcat:*" file-patterns  "*.usd[ac] *.usd *.abc *(-/)"
zstyle ":completion:*:*:usdtree:*" file-patterns  "*.usd[ac] *.usd *.abc *(-/)"
zstyle ":completion:*:*:blender:*" file-patterns "*.blend *(-/)"
zstyle ":completion:*:*:blenderdebug:*" file-patterns "*.blend *(-/)"
zstyle ":completion:*:*:dot2png:*" file-patterns "*.dot *(-/)"
zstyle ":completion:*:*:gaffer:*" file-patterns "*.gfr *(-/)"
zstyle ':completion:*' completer _complete
zstyle ':completion:*' matcher-list '' 'm:{[:lower:][:upper:]}={[:upper:][:lower:]}' '+l:|=* r:|=*'

The last line is some magic that makes ZSH autocomplete using substrings instead of prefixes. In other words, it has tab completion also on the middle of a filename. This makes it possible to type mplayer mjpeg{tab} and get mplayer llama.mjpeg (this file was the only .mjpeg file in the directory).

Key Bindings

bindkey -e
bindkey "^[[3~"  delete-char
bindkey "^[3;5~" delete-char
bindkey "^K" kill-line

# Ctrl left/right for word skipping
bindkey ';5D' backward-word
bindkey ';5C' forward-word

my-backward-delete-word() {
    local WORDCHARS=${WORDCHARS/\//}
    zle backward-delete-word
}
zle -N my-backward-delete-word
bindkey '^W' my-backward-delete-word

The last big is to make Ctrl+W erase only a word, and not the entire line.

Fuzzy Finder

For searching through history I use Fuzzy Finder. It makes it much easier to find previous commands, as it doesn’t require you to search for it exactly. This means that you can just do {Ctrl+R}code blender to find code ~/workspace/blender-git/blender.code-workspace.

Another very nice thing is that Enter only selects the command from history. You then have the opportunity to edit it, before pressing Enter again to execute it.

Build before Debug in VSCode

Thu, 23 Jul 2020 10:11:43 +0200

For debugging Blender I have set up my IDE Visual Studio Code such that it builds Blender whenever I start the debugger. Before I did this, I would ofte forget to manually build Blender, causing all kinds of confusion when the code didn’t match up with the behaviour.

Running a compiler before starting the debug sessions concerns a few files. First we need a task in .vscode/tasks.json. Here I added two tasks, one for a release-mode build and one for a debug-mode build:

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Build Release",
            "type": "shell",
            "command": "nice -n 20 ninja -C /home/sybren/workspace/blender-git/build_linux/",
            "problemMatcher": [
                "$gcc"
            ]
        },
        {
            "label": "Build Debug",
            "type": "shell",
            "command": "nice -n 20 ninja -C /home/sybren/workspace/blender-git/build_debug/",
            "problemMatcher": [
                "$gcc"
            ]
        }
    ]
}

Then we need to update launch.json to run that task before starting Blender itself. Note the preLaunchTask, which is set to the label of the task to run:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Blender",
            "type": "cppdbg",
            "request": "launch",
            "program": "/home/sybren/workspace/blender-git/build_debug/bin/blender",
            "args": [],
            "stopAtEntry": false,
            "cwd": "/home/sybren/workspace/blender-git/blender",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "preLaunchTask": "Build Debug",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

That’s all there is to it. Now whenever I press F5, a new debug build is made, and Blender starts, and debugging can begin.

Simple Amplifier

Mon, 06 Jul 2020 21:18:34 +0200

The Simple Amp

I built an amplifier! This little fella is going to replace the big old amp that I use to hear my electric drumkit. I have made amplifiers before, but this one is by far the best-sounding (and most powerful) one so far.

It’s made using only three transistors, two of which are the big boys you see in the photo above. They come from an old amplifier that I got from a friend and took apart for, well… parts.

Circuit diagram of the Simple Amp

The schematic shows how everything fits together. Transistors Q2 and Q3 form a push-pull configuration, and are biased by diodes D1 and D2. Transistor Q1 amplifies the signal; its bias is automatically corrected by the feedback resistor R6.

The bottom of the board shows the tracks and SMD components

Since it’ll be sitting in the same spot connected to the same things, it just has some solder connections. The audio inputs will get jack connectors, and the speaker will just be soldered on.

The PCB I made myself using UV exposure, etching with sodium persulfate, and some drilling. One day I’ll make some videos about the entire process.

I already have plans for the next amplifier, which will be stereo and have a volume knob and some actual connectors :)

Drone Panoramas Explained

Mon, 29 Jun 2020 19:19:03 +0200

Sometimes people want to know how I create my spherical drone panoramas. I though it would be a nice touch to just write it down, so that’s what I did.

Check out my article on creating 360 degree spherical panoramas with a drone.

Miniature Planets

Sun, 28 Jun 2020 14:46:44 +0200

For a long time I’ve been making miniature planets. Until now it was mostly for fun, but finally I’ve added a section dedicated to them to my photo website!

Take a look at my miniature planets gallery. There are 6 planets now; expect the collection to grow :)

Planned Changes to Blender's Alembic Exporter

Mon, 22 Jun 2020 18:56:17 +0200

Recently I have been working on a new Alembic exporter, in such a way that both Universal Scene Description (USD) and Alembic can be exported using the same code base. This makes the export of Alembic and USD consistent, but does cause some changes that I would like community feedback on.

The actual blog post is not here, but at the Blender Developers Blog.

Scripting for Artists Chapter 2

Thu, 18 Jun 2020 20:24:51 +0200

On Blender Cloud, there are of course lots of Blender tutorials. One of those has my face on it: Scripting for Artists. It is a Python scripting series aimed at artists, and starts from the simplest of beginnings (just copy-pasting stuff).

As relief during the COVID-19 worldwide quarantaine, I got the opportunity to add a new chapter to this series. Even better: this new chapter is completely free for everybody! The entire series is available on Blender Cloud, with the free chapter also available on YouTube.

I got so many nice responses! It’s been an amazing journey, making these tutorials from the comfort of my own kitchen, and then helping so many people solving actual problems and making their lives more pleasant.

Only available on YouTube are the Live Scripting for Artists Q&A on Blender Everyday and my 2017 Blender Cloud workshop on the subject.

Need Help?

If you want help with Python scripting in Blender, pop over to Blender Chat and visit the #python channel. There you’ll find plenty of people who’re happy to help you out.

Python-RSA 4.5 & 4.6 released!

Thu, 18 Jun 2020 18:42:54 +0200

The final release of Python-RSA v4.6 can be obtained from the Python Package Index, or just installed with pip install --upgrade rsa. Running that upgrade command on Python 2.7 will automatically give you version 4.5, the last version to support Python 2.

This release contains improvements by Alexey Sveshnikov, Jon Dufresne , Andrey Semakin, Christian Heimes, Adelapie, and myself of course:

Added support for Python 3.8.
Dropped support for Python 2 and 3.4.
Added type annotations to the source code. This will make Python-RSA easier to use in your IDE, and allows better type checking.
Added static type checking via MyPy.
Fix #129 Installing from source gives UnicodeDecodeError.
Added support for SHA3 hashing: SHA3-256, SHA3-384, SHA3-512. This is only supported by Python 3.6+.
Choose blinding factor relatively prime to N. Thanks Christian Heimes for pointing this out.
Reject cyphertexts (when decrypting) and signatures (when verifying) that have been modified by prepending zero bytes. This resolves CVE-2020-13757. Thanks Adelapie for pointing this out.

More information on the Python-RSA page.

What about versions 4.1 - 4.4?

Ok, so here is the whole story about where versions 4.1 - 4.4 disappeared to.

After sitting on some smaller improvements for a while, in fairly rapid succession I received two reports about security issues. The first one was regarding the chosen blinding factor. The second one was more serious; serious enough to warrant a CVE: CVE-2020-13757.

Fortunately both issues were relatively easy to fix, so I rapidly released version 4.1. This was the first release to be built with Poetry and with SHA3 support. As it turned out, packages made with Poetry cannot be installed in a no-binaries environment, and the same goes for the SHA3 support library needed on Python 3.5. So, out came Python-RSA version 4.2 to resolve those issues.

Version 4.1 was also the first to discontinue support for Python 2.7. This version of Python has been marked end-of-life since the beginning of this year. That deprecation didn’t go too smoothly, though; apparently the setup.py code missed a bit of metadata that declares that the package requires Python 3.5+, so installations that were still using Python 2.7 were happily installing the new Python-RSA version, and failing badly.

To help the Python 2.7 users, I took Python-RSA 4.0 (the last one to support 2.7), cherry-picked the two security issues, and released it as Python-RSA version 4.3. After that I took version 4.2 and released that as version 4.4, this time with the right python_requires = ">=3.5" in place to make sure Python 2.7 won’t try to use it.

I tried to do it all too quickly, so I accidentally released version 4.4 without that python_requires stanza. So, still Python 2.7 installations tried to upgrade and got broken, which is why I re-released version 4.3 as version 4.5 and re-released version 4.4 as version 4.6.

There you go. Now you know.

New Website

Wed, 17 Jun 2020 17:59:35 +0200

Today I launched my new website, with a new look and underlying tech, but all the old content. This makes my website faster, more modern, mobile-friendly, and more secure. More importantly, it makes it easier for me to share more stuff, so my blog will become more alive as well.

My old website was made with Django. I still feel that Django is a great framework, but it’s a bit overkill for my needs. This new site is using Hugo, a static site generator.

Everything should still work. The URLs of pages have changed, but the old ones should redirect to the new locations. If something is broken, please let me know.

Slovenia & Croatia spherical panorama pack in Blender Cloud

Thu, 20 Jun 2019 17:05:08 +0200

Last year we went on holiday to Slovenia & Croatia (mentioned here in chronological order of visiting) and made a set of 360°x180° panorama photos. They are available as high dynamic range EXR files on Blender Cloud. There are multiple versions available, with resolutions up to approximately 135 megapixel.

Skyfill v1.1 released

Mon, 06 May 2019 09:53:19 +0200

Version v1.1 of Skyfill has been released. The most important improvement is that it now also supports full-white as fill colour for the sky. You can grab your copy at Gitlab.

Skyfill allows you to do fill in the gap in the sky in high-resolution images.

Skyfill released!

Sun, 17 Mar 2019 13:44:23 +0100

Skyfill allows you to do fill in the gap in the sky in high-resolution images.

Original image, before applying Skyfill

Skyfilled image

For more info see the project on Gitlab, or just download the software.

Thanks to Ork de Rooij for his help getting the pixels right.

I also put two new panoramas online on stuvelfoto.nl, both of course with the help of Skyfill: Äkäslompolo in Finland and Ringweg Amsterdam.

FFmpeg and DJI D-Log on the Mavic 2 Pro

Mon, 21 Jan 2019 13:43:53 +0100

To properly see a video recorded with a DJI Mavic 2 Pro in D-log colours, it needs conversion. This can be done with the cube file provided by DJI. Such cube files contain the lookup table (LUT) to turn the bland colours into proper ones when viewing with a run-of-the-mill viewer like MPlayer, VLC, Windows Media Player, etc.

Unfortunately, DJI’s cube file is incompatibe with FFmpeg. It should work with this command, but doesn’t:

ffmpeg -i input_file.mp4 -c:v h264 -crf 21 \
    -vf lut3d='dlog-to-rec709.cube' output_file.mp4

This results in an error “3D LUT is empty” from FFmpeg. Fortunately, this is easily fixed. Just open the .cube file in any text editor, and find the line LUT_3D_SIZE 33. There is a tab character between the LUT_3D_SIZE and 33, and even though this is fine according to the specifications, FFmpeg doesn’t like it. Just replace it with a space, so change:

LUT_3D_SIZE<tab>33

into:

LUT_3D_SIZE<space>33

Save the file, and you’re done. The above ffmpeg command will now just work.

Update: this incompatibility has been fixed in FFmpeg, and will be part of a future release (current release is 4.1).

Python-RSA 4.0 released!

Sun, 16 Sep 2018 14:23:59 +0200

After over two years of silence, Python-RSA 4.0 has been released! There are many improvements and also backward-incompatible changes (hence the increase of the major version number).

Get it while it’s hot at the Python Package Index, or just install with pip install --upgrade rsa.

This release contains improvements by adamantike, Alexandr, David Larlet, Fabio Alessandro Locati, Florian Motlik, Hugo, Jon Banafato, Jon Dufresne, Joost Rijneveld, Justin Simon, Michael Manganiello, yjqiang, and myself of course.

Dropped support for Python 2.6 and 3.3.
These modules were deprecated in version 3.4, and are now removed:
- rsa.varblock
- rsa.bigfile
- rsa._version133
- rsa._version200
Removed CLI commands that use the VARBLOCK/bigfile format.
Ensured that PublicKey.save_pkcs1() and PrivateKey.save_pkcs1() always return bytes.
Dropped support for Psyco.
Miller-Rabin iterations determined by bitsize of key. #58
Added function rsa.find_signature_hash() to return the name of the hashing algorithm used to sign a message. rsa.verify() now also returns that name, instead of always returning True. #78
Add support for SHA-224 for PKCS1 signatures. #104
Transitioned from requirements.txt to Pipenv for package management.

All mail is mine

Wed, 07 Feb 2018 11:23:59 +0100

While I’m doing web development I want to have an email server that ensures that all mail will end up in my mailbox. To this end I set up Postfix with this rule in main.cf:

header_checks = regexp:/etc/postfix/header_checks.regexp

The header_checks.regexp then contains:

/^To:/ REDIRECT sybren+keep-local@my.domain

This results in all mail being sent via my SMTP server is delivered to my mailbox, regardless of who it’s intended for.

Python FlickrAPI 2.3 released

Mon, 08 May 2017 13:11:14 +0200

A new version of the Python FlickrAPI has been released. You can download or upgrade it using pip3 install -U flickrapi.

Changes are:

Include README.md and CHANGELOG.md in the package data.
Removed flickrapi/contrib.py, as a persistent connection is now managed (much better) by requests (since cdeb6ffea26).
Late-import module webbrowser, only when needed (Thijs Triemstra) [ Pull request #78 ]
Perform explicit commit after inserting auth token (Joshua Hunter) [ Bug report #75 ] [ Pull request #76 ]
Configured Tox & Travis to test on Python 3.6 as well.
Timeout for API calls. [ Feature Request #27 ]
Late-import SQLite3 to allow running on Heroku (and other systems). [ Feature Request #81 ]
Fixed using obsolete func_name attribute. [ Bug report #80 ]

Blender Conference 2016

Mon, 31 Oct 2016 16:01:22 +0100

BConf 2016 was awesome, as ever. This is just a blog post to share the slides of my workshop “ Develop add-ons like a pro”.

I'm a PhD & work at Blender!

Thu, 21 Apr 2016 08:25:27 +0200

Yesterday I obtained my PhD degree in Computer Science at the Universiteit Utrecht, on the subject of the simulation of dense crowds. Of course my thesis Dense Crowds of Virtual Humans is available online!

And, as of March 1st, I’m an employee of the Blender Institute, I landed my dream job!

Python-RSA 3.4 released

Thu, 17 Mar 2016 13:53:50 +0100

Python-RSA 3.4 has been released! This is the first release from GitHub, and contains a lot of improvements by myself, Michael Manganiello, and Filippo Valsorda, including the solution for a side-channel vulnerability.

Get it while it’s hot at the Python Package Index, or just install with pip install --upgrade rsa.

The changes are:

Moved development to Github: https://github.com/sybrenstuvel/python-rsa
Solved side-channel vulnerability by implementing blinding, fixes #19
Deprecated the VARBLOCK format and rsa.bigfile module due to security issues, see https://github.com/sybrenstuvel/python-rsa/issues/13
Integration with Travis-CI, Coveralls and Code Climate.
Deprecated the old rsa._version133 and rsa._version200 submodules, they will be completely removed in version 4.0.
Add an ’exponent’ argument to key.newkeys()
Switched from Solovay-Strassen to Miller-Rabin primality testing, to comply with NIST FIPS 186-4 as probabilistic primality test (Appendix C, subsection C.3).
Fixed various bugs.

Version 3.4 is the last version in the 3.x range. Version 4.0 will drop the following modules, as they are insecure:

rsa._version133
rsa._version200
rsa.bigfile
rsa.varblock

Those modules are marked as deprecated in version 3.4.

Furthermore, in 4.0 the I/O functions will be streamlined to always work with bytes on all supported versions of Python.

My name in the modern world

Thu, 04 Feb 2016 12:20:39 +0100

My last name is a technical hurdle. At least, for many people. In this high-tech, modern, globalized society, one would expect that a simple accented character shouldn’t be an issue. After all, even a small child can write Stüvel correctly with a stick in the mud. So why is it such an issue in the world of computers?

To demonstrate the issue, here is a list of ways that I have seen my name appear:

StÃ¼vel
St??vel
St�vel
St++vel
Stüvel
St\xc3\xbcvel
St vel
St☐☐vel
St³vel
StĂźvel
StÃ╝vel
St? <Input Name=
St~vel
StÃ☐Ã¼vel
StÃOvel
St?üvel
Stï¿½ï¿½vel
St?vel
“your last name contains illegal characters”
“your last name should contain at least one alphabet”, “only enter alphabetical characters”, etc.
STÃœVE
Stãœvel
“you did not fill in a last name” and variants thereof
St
“your last name should contain only letters”
St_f_»vel
St√É¬ºvel

The root cause? Often software is only tested with what the developers & testers can easily type on their keyboard. As a result, they use the characters from the ASCII set, which happens to be the common dinominator between many character encodings. If you want to ensure your system correctly handles character data, test with non-ASCII characters. Go to Wikipedia, pick a random article in a language you don’t know, and just copy-paste some text into your application. Your system should be set up to handle this. Preferably by using UTF-8, but as a worst-case it should at least let the user know that non-ASCII characters aren’t supported.

And please, don’t call those “illegal” or “special” characters. It’s not a property of the characters, but a limitation of your system. Those limitations are usually simple to lift, as long as testing with non-ASCII characters is part of the development process.

Let’s move into the modern world, and accept the view that there are more names than English ones. The best thing to read after this, one of my favourite pages on the web, Falsehoods Programmers Believe About Names.

New website & Python-RSA 3.3

Mon, 18 Jan 2016 21:29:40 +0100

You won’t notice it, but you’re now on my new website. The look is still the same, but under the hood a lot has changed. This includes the blog being fixed again, so that I can actually write new posts! Can you imagine, I didn’t blog a single thing in 2015…. well, that’ll change.

Python-RSA 3.3 has been released! This release fixes a security leak, which was filed under CVE-2016-1494. As always, you can get the new version from the Python Package Index.

Python FlickrAPI 2.0 released

Thu, 06 Nov 2014 17:55:41 +0100

Python FlickrAPI library version 2.0 has been released, and can be downloaded from the Python Package Index with more info at my FlickrAPI page.

The major change is that the “new” OAuth-based authentication is used. This makes our Python FlickrAPI library a lot more future-proof.

Thanks to Jim Easterbrook, Thai Nguyen, Nick Loadholtes and Bengt for their contributions.

Panoramas: two terraces

Thu, 21 Aug 2014 21:13:08 +0200

UPDATE 2019: The panoramas are currently broken, I’ll get around to fix it some time in the future.

I just put two new 360/180 degree panoramas online, of places very well suited for an exquisite dinner.

Camping Slapić

Hotel Haus am Berg

Enjoy!

Moving from pwsafe to KeePass

Wed, 30 Jul 2014 11:01:38 +0200

My favourite password management tool, pwsafe, is getting old. It’s no longer part of Ubuntu and I’ve had to compile it myself for quite a while now. It’s also not supported on Android, and shows other signs of aging. So, I moved to KeePass. Exporting my database to CSV was simple, and to make the job of importing it correctly into KeePass even easier, I wrote a simple Python script.

import csv

infile = open('passwords.csv', encoding='utf-8')
outfile = open('passwords-groupfixed.csv', 'w', encoding='utf-8', newline='')
incsv = csv.reader(infile, delimiter='\t')
outcsv = csv.writer(outfile)

for rowidx, row in enumerate(incsv):
    if rowidx == 0:
        # Skip comment row
        continue

    if rowidx == 1:
        outcsv.writerow(['uuid', 'Title', 'User name', 'Password', 'Notes', 'URL'])
        continue

    if len(row) != 6:
        raise SystemExit('Weird row: {}'.format(row))

    uuid, group, name, login, passwd, notes = row
    if group:
        name = group + '.' + name

    url = ''
    if notes.startswith('http') or notes.startswith('www'):
        url, notes = notes, url

    outcsv.writerow([uuid, name, login, passwd, notes, url])

This script takes the pwsafe CSV and transforms it into a CSV file that can be plugged into KeePass without any further configuration. Nice and easy!

Python FlickrAPI 1.4.4 released

Wed, 18 Jun 2014 07:05:12 +0200

Python FlickrAPI library version 1.4.4 has been released, and can be downloaded from https://pypi.python.org/pypi/flickrapi with more info at https://stuvel.eu/flickrapi

The changes are:

Changed default API URL to use HTTPS (Joseph Hui).
PEP 8 compliance (Luar Roji).
Replaced Distribute with Setuptools.

In the mean time, we have made more progress on the upcoming version 2.0. We can always use more bug testers, bug fixers and documentation writers; check out https://bitbucket.org/sybren/flickrapi/ to get involved!

Reloading your code in Blender

Mon, 10 Mar 2014 13:57:11 +0100

UPDATE 2019: Things are considerably simpler. Just press F8 in Blender 2.79 or older, or press F3 and search for ‘Reload Scripts’ in recent Blenders.

Blender lets you script more or less everything. You can have your code inside Blender (and the .blend file) itself, but I prefer to store it outside the .blend file. This makes it easier to handle changes, and allows you to use any editor you want. The downside is that reloading your code becomes a bit of a hassle. This is a little snippet I wrote to reload my code in Blender with the click of a button.

import bpy
import imp
import os.path
import sys

my_path = bpy.path.abspath('//')

if my_path not in sys.path:
    sys.path.insert(0, my_path)

def load_my_stuff():
    # This imports my main module and registers its contents.
    # Alter to suit your needs.
    import calc_distance
    calc_distance.register()

def reload_my_modules(base_path):
    '''Reloads all my modules.

    "my modules" are those that are stored in the same directory (or subdir)
    of this .blend file.
    '''

    base_path = os.path.normpath(base_path)  # normalize the path
    my_module = sys.modules[__name__]

    print('Reloading from %r' % base_path)
    # Only allow reloading of pure-Python (i.e. not compiled) modules,
    # that have a __file__ and that are not this specific module.
    reloadable = (module for module in sys.modules.values()
                  if hasattr(module, '__file__') and
                     module != my_module and
                     (module.__file__.endswith('.py') or
                      module.__file__.endswith('.pyc')))

    for module in reloadable:
        modpath = os.path.abspath(module.__file__)
        common = os.path.commonprefix([base_path, modpath])
        if os.path.commonprefix([base_path, modpath]).startswith(base_path):
            print('    Reloading %s from %s' % (module, module.__file__))
            imp.reload(module)

    # re-register the reloaded classes.
    load_my_stuff()

class ReloadScriptsOperator(bpy.types.Operator):
    bl_idname = 'script.reload_my_scripts'
    bl_label = 'Reload code'
    bl_description = 'Reloads all distance code.'

    def execute(self, context):
        my_path = bpy.path.abspath('//')
        if not my_path:
            self.report({'ERROR'}, 'Save the Blend file first, before reloading')
            return {'CANCELLED'}

        reload_my_modules(my_path)
        return {'FINISHED'}

print(80 * '*')
print('Registering %s and the rest' % __name__)
bpy.utils.register_module(__name__)

load_my_stuff()

The code makes one assumption that’s important to know: it assumes that the Python files you want to reload are in the same directory as your Blend file (or subdirectory thereof). This means that you must save your Blend file before this works. If you store your code in a different directory, you’ll have to modify the matching against my_path to suit your needs.

In order to have the “Reload code” button in the user interface somewhere, add this line to your UI code:

layout.operator('script.reload_my_scripts')

For completeness, here are the relevant parts of my custom UI panel:

class ReloadExamplePanel(bpy.types.Panel):
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'TOOLS'
    bl_category = "Tools"
    bl_context = "objectmode"
    bl_label = "Reload button example"

    def draw(self, context):
        layout = self.layout
        layout.operator('script.reload_my_scripts')

        # Here I draw more stuff, but that's irrelevant if you don't have my code.

def register():
    print('Registering %s' % __name__)
    bpy.utils.register_module(__name__)</pre>

Counting pixels in Blender

Fri, 28 Feb 2014 09:21:33 +0100

UPDATE 2019: the image of the node setup has been lost.

For my research, I’m using Blender to generate images. I wanted to know how visible a certain object is in the final render (i.e. how many pixels it occupies). For this there is the “object index” render pass (aka “IndexOB” in the compositor). I’ve been struggling with it, since it always outputs that the index is 0, even though there are multiple objects in the scene.

Well, with the help of mfoxdogg on the #blender IRC channel, we found a solution: You need to set the index by hand, for every object you’re interested in. If you go to the object properties (in the properties explorer), in the section “Relations” there is a slider “Pass Index”. This is set to 0 by default, and you can set it to any positive number you want. This is then reflected in the output of the “IndexOB” render pass.

So to solve my problem, I needed to count the pixels that a certain object occupies in the image. For this I connected a viewer node to the “IndexOB” pass. Once you’ve rendered, you can then access the pixel data using bpy.data.images['Viewer Node'].pixels. It’s a one-dimensional array of floats, in the RGBA format. This means that every pixel is represented as four consecutive floats.

The IndexOB data is stored in the RGB channels, and the alpha channel is set to 1.0. You could write some code to only inspect the R channel for its value and count the ones that are equal to the object index you’re interested in. I chose a more lazy approach of counting all RGBA values that are equal to the index, then dividing by 3. For this you do need an object index larger than 1, as the alpha channel is always set to 1 too. So here is the code:

import bpy

# I'm interested in the object named "L"
ob_name = 'L'

# Set the "pass index"
bpy.data.objects[ob_name].pass_index = 42

# Render the image
bpy.ops.render.render()

# Count all pixels that have value = 42. We count all R, G and B components
# separately, so divide by 3 to get the actual number of pixels
pixel_count = sum(1 for p in bpy.data.images['Viewer Node'].pixels if p == 42) / 3
print('Pixel count for object %r : %i' % (ob_name, pixel_count))

Python-RSA version 3.1.4 released

Sat, 22 Feb 2014 10:55:39 +0100

It’s been a while since I’ve been working on my RSA library, and in the last weeks I’ve released a few new minor versions. Here are the differences since my last blog post about it:

Fixed Python 3.x incompatibilities.
Dropped support for Python 2.5.
Added support for loading public keys from OpenSSL
rsa.pkcs1.verify() returns True when successful (thanks Tim Heckman)
First updated Distribute (thanks Jason R. Coombs), later replaced Distribute with Setuptools.
Fixed typo in pyrsa-verify help message

Comments via Disqus

Mon, 20 Jan 2014 19:47:23 +0100

UPDATE 2019: I’ve removed the ability to comment altogether.

My blog has been targeted by spammers for years. The last months spam has been on the rise, so I finally got fed up with it and replaced my home-grown comment system with Disqus. Old comments are still there, new ones will be using Disqus instead.

Installing Windows 8 with different product key

Thu, 31 Oct 2013 10:32:43 +0100

New laptops often are shipped with the Windows product key stored in the EFI/BIOS/whatever. The result is that you don’t get a product key prompt any more. Great for reinstalls, as copying the key by hand is very error-prone. However, when I wanted to install a fresh Win8 Pro version, the embedded “Home” version key wasn’t accepted and the installer did not ask for another key. It was simply impossible to install Windows 8 Pro.

This blog post will describe how I got it installed in the end.

Get a USB stick that’s large enough - 4 GB or more should do it.
Transfer an ISO file of the Windows installation disk to the USB stick, using Microsoft’s USB DVD tool. Please note that this will erase any contents of your USB stick.
On the USB stick, create a file sources\PID.txt that contains:
```
[PID]
Value=XXXXX-XXXXX-XXXXX-XXXXX-XXXXX
```
Replace the XXXXses with your product key.
Copy all files from the USB stick back to your harddisk.
Reformat the stick as FAT32. Microsoft’s tool has formatted it as NTFS, which is not supported as a boot device for newer laptops (i.e. the ones you need this trick for in the first place).
Copy all files back from your harddisk to the USB stick.
Eject the USB stick. You need to do this cleanly (don’t just jank it out) to ensure that all files were written to it. You don’t want to have to redo your installation because it failed halfway, do you?
Boot from the USB stick to install Windows. It will not prompt for the product key, but use the one you specified in sources\PID.txt.

Blender conference 2013

Wed, 30 Oct 2013 10:21:29 +0100

Last weekend Amsterdam was visited by a great group of over 250 Blender professionals and enthousiast, for the Blender Conference 2013. This year it was my pleasure to give a workshop about my research, and how I use Blender to visualize my result.

For the attendants (and other interested people), I’ve put my presentation, the Blender file and accompanying SQLite database online: https://stuvel.eu/files/bcon_2013_sybren_workshop.7z

You can still see the workshop online on Youtube. Tthe first 10 minutes is just people leaving the previous workshop, and me setting up, though.

Lancering nieuwe website

Sun, 01 Sep 2013 12:33:32 +0200

Speciaal voor mijn fotografie is er vandaag een nieuwe website gelanceerd: https://stuvelfoto.nl/

Deze site is volledig gericht op fotografie: huwelijksreportages, portretten en panorama’s.

Binnenkort zal ook stuvel.eu een verandering doorgaan, aangezien alle fotografie-gerichte onderdelen nu een nieuw plekje op https://stuvelfoto.nl/ hebben.

UPDATE 2019: Ik ben gestopt met trouwreportages. Portretten en panorama’s maak ik des te meer.

Ten reasons I don't like Visual Studio

Mon, 26 Aug 2013 13:38:25 +0200

For my work I’m using Microsoft Visual Studio 2010 (VS) to write our C++ code. There are so many things wrong with this IDE that I just had to write this post. Here’s a list of why I think it’s crap:

The compiler requires certain environment variables, that are set by running a batch file. The result is that it’s very hard to integrate the compiler into another IDE such as Eclipse. Yes, it’s possible, but a very big hassle. This effectively locks you into using their IDE, which makes its shortcomings even more annoying.
Code completion (“intellisense”) is often so slow that it’s often faster for me to scroll through my sources and copy-and-paste a symbol myself.
Code completion (“intellisense”) is dumb. It usually prefers some obscure symbol that I’ve never used before, over the name of a local variable I declared a few lines earlier. Compare this to PyCharm, where the first or second suggested symbol is usually correct.
There is no overview of the file you’re currently working in, like the “outline” views offered by Eclipse and PyCharm.
There is no way to show the location of the file you’re currently working on in the Solution Explorer.
No refactoring. At all. There is no easy way to rename a symbol, to extract code into a new method, extract a variable, etc.
When debugging a console application, the output is sent to a little window I can’t resize, which closes immediately upon termination of the program. WTF? All other IDEs I’ve used send the program’s output to a window inside the IDE, so that you can actually inpect the output or read error messages, after your program has stopped.
The project property popup always reverts back to the current configuration (you know, the “Debug”, “Release” etc. thingies), even though 99% of the time I want the “All Configurations” configuration as I want most of the project settings to be consistent between debug and release.
Firefox, Chrome, Eclipse, PyCharm, all kind of environments where you’re working with multiple documents in different tabs, you can use keyboard shortcuts to go from one to the other (I prefer Ctrl+Page up/down). If you want the same behaviour in VS, you need to install an extension before you can set up your keybindings.
VS doesn’t react to the forward/backward mouse buttons. Those are so handy when you quickly have to change something (like add an #include statement) and then go back to where you were before.

Portretten in het park

Wed, 31 Jul 2013 21:11:16 +0200

21 juli werden bij de Noorderparkbar liefdesliedjes gedraaid door Döske en liefdesstoelen gepresenteerd door Marc. Een uitgelegen moment om wat intieme portretten te maken.

Geschoten met m’n Hasselblad 500 C/M op Kodak Tri-X 400 film. Afgedrukt op Ilford Multigrade papier met Ilford Warmtone ontwikkelaar.

Sterkste man van Zaanstad 2013

Thu, 18 Jul 2013 21:34:10 +0200

Afgelopen zaterdag waren we bij de Sterkste Man van Zaanstad, om onze vriend Vlad aan te moedigen en natuurlijk om foto’s te maken. Het resultaat: Vlad is 1e geworden, en wij hebben deze foto’s:

Ga naar het overzicht van alle foto’s.

Orange & Teal

Sat, 29 Jun 2013 08:47:56 +0200

Check out this blog post on the typical look of the Hollywood blog buster movies: Teal and Orange - Hollywood, Please Stop the Madness.

It was linked by this post Colour Correction Overload?, in which the author asks us whether colour grading is getting too much. I know I found the Harry Potter films a bit too much in that area, and other movies too. What do you think?

Bl3nder in de Melkweg

Sun, 30 Dec 2012 21:16:31 +0100

Bl3nder gaf gisteren een spetterend optreden in de Melkweg in Amsterdam. Natuurlijk werden nummers van hun nieuwe album Gekkenhuis, hun “gouwe ouwe” Leipe Shit Ouwe! en werden we getrakeerd op heerlijke funky en jazzy jams.

Als fotograaf kon ik gaan en staan waar ik wilde, en zelfs vanaf het podium fotograferen. Hier onder vind je een paar foto’s, de rest staat online op Flickr.

Deze en meer foto’s staan online op Flickr!

Start XBMC from remote

Sun, 09 Dec 2012 02:35:37 +0100

The Android XBMC Remote app has a “Power on” button. This button sends a wake-on-lan (WOL) packet to the XBMC server, so that it can wake up. However, my XBMC server runs all kinds of server stuff, so I don’t want to let it sleep. Still, XBMC uses more than 10% CPU power even when it’s in idle, so I don’t want it running all the time either.

I’ve written a small Python script that executes a command every time it receives a WOL packet. This is then used to start XBMC. Here is the Python source code:

# wol-trigger.py

import socket
import struct
import os
import sys
import subprocess

if 'SUDO_UID' not in os.environ:
    raise SystemExit('Run with sudo')

# Try to parse these before spawning another process
uid = int(os.environ['SUDO_UID'])
gid = int(os.environ['SUDO_GID'])

# Let the user know what will happen
cmdargs = sys.argv[1:]
if cmdargs:
    print('Going to call:')
    print('    %s' % ' '.join(cmdargs))
    print('As UID=%i / GID=%i' % (uid, gid))

# Open the port now we still have root rights.
port_nr = socket.getservbyname('discard', 'udp')
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind(('255.255.255.255', port_nr))

# Drop root rights and become mortal again.
os.setgid(gid)
os.setuid(uid)

try:
    while True:
        packet = sock.recv(102)

        padding = struct.unpack('BBBBBB', packet[0:6])
        if padding != 6 * (255, ):
            hexpad = ':'.join(hex(b) for b in padding)
            print('Invalid WOL packet received: %s' % hexpad)
            continue

        address = struct.unpack('BBBBBB', packet[6:12])
        mac = ':'.join(hex(a) for a in address)

        if cmdargs:
            print('Starting %s' % (cmdargs, ))
            subprocess.call(cmdargs)
        else:
            print('Received WOL from %s' % addr)
except KeyboardInterrupt:
    pass

It is a very minimalistic script, that doesn’t even check the MAC address in the WOL packet. If you need it, it’s simple enough to add it in. You need to run it with:

sudo python wol-trigger.py xbmc

Or with any other command or shell script you want to execute when you receive a Wake-On-Lan magic packet. It needs to be run with sudo because the WOL port is 9, which is lower than 1024 and thus needs root rights to listen on. The command to be executed will be running with the rights of the user running sudo, and not as root:

$ sudo python wol-trigger.py id
Going to call:
    id
As UID=1000 / GID=1000
Starting ['id']
uid=1000(sybren) gid=1000(sybren) groups=1000(sybren),0(root)</pre>

The script only works on Linux, but I’m sure it can be modified to work on other systems too. That’s up to you, though ;-)

Vlad Buda

Thu, 01 Nov 2012 07:50:56 +0100

My friend Vlad trains at Raw Power Baarn. A few months ago I went to one of his training sessions, and I was very impressed by not only their strength of body but also of the mind. Vlad knows exactly what kind of signals his body sends, which pain he can push through, and when to stop.

Most of the photos I shot on Ilford Delta 3200. Back then I still used an old light meter that turned out to be very inaccurate in dark situations, so unfortunately the film was heavily underexposed. I’m quite happy with the result I got, though, it came out much better than I expected (after I did a lot of measurements and printed with the highest filtration for the most contrast).

The photo below is the only one I didn’t shoot on Ilford Delta 3200, but on Kodak Tri-X 400:

Vakantiefoto's

Sat, 08 Sep 2012 15:21:24 +0200

Dit jaar zijn we weer naar Kroatië gegaan, en hebben we een heel aantal bol-panorama’s geschoten. Daarnaast ook een hoop zwart-wit foto’s met mijn Hasselblad 500 C/M. Hier onder vind je er alvast twee, de rest moet ik nog afdrukken en scannen.

First photos with a Hasselblad

Sat, 28 Jul 2012 17:00:32 +0200

These are the first photos I’ve taken with my Hasselblad 500 C/M. I was actually planning of shooting in black & white mostly, but since I had some unused colour film in my fridge I thought it would be a good idea to practice with that. Turns out I really like the result! The colours are vivid, but still look natural, and the bokeh of the lens is simply terrific. I love this camera!

Trying out T-Max 400

Fri, 27 Jul 2012 11:13:02 +0200

One of my favourite photographers, Stephan Vanfleteren, seems to shoot Kodak T-Max 400 film (the film is labeled Kodak 400TMY as you can see in some of his portraits). I wanted to give the film a try too, so I met up with my friend and willing subject Matthijs for a Sunday morning photoshoot in the park. Here is the first result.

Matthijs #4

Matthijs #10

How much can you say about a film after a single shoot? Well, I’m going to try anyway. So far I like the details that are captured. It still feels a little too “clean” for me, lacking a bit of punch or depth. That may have something to do with my still-developing skills in the darkroom, though. So far it hasn’t won me over – Kodak Tri-X 400 will remain my favourite. For now - who knows what the future brings!

Matthijs #12

Hasselblad 500 C/M

Tue, 24 Jul 2012 19:22:55 +0200

My Hasselblad 500 C/M

I have wanted a Hasselblad for years, and last Sunday I bought this Hasselblad 500 C/M, with 80mm f/2.8 Carl Zeiss Planar T* lens, waist-level finder and A12 film back. It’ll be a long wait for the first photos to come back from the lab!

My Hasselblad 500 C/M

Python-RSA version 3.1.1 released

Sun, 17 Jun 2012 10:11:58 +0200

Python-RSA version 3.1.1 has been released. A lot of things have been improved, thanks to Yesudeep Mangalapilly.

Much, much faster
Compatibility with Python 3.2
Lot of bug fixes

Check the Python-RSA page for more information!

Observant readers may have noticed that I snuck in a tiny minor release. Version 3.1.1 introduces full Python 3.2 compatibility for the key saving/loading stuff as well, and fixes some doctests for Python 2.7. Nothing in the actual RSA stuff was changed.

Sheepies in Utrecht

Tue, 01 May 2012 20:39:46 +0200

The campus of Utrecht University has a small field with sheep, and today I got up close and personal. One of the big sheep was even tame enough to let me stroke and pat it!

Long romantic weekend in Paris

Sat, 21 Apr 2012 15:48:32 +0200

Marit and I had a long, very romantic weekend in Paris a few weeks ago. Photo-wise all I took with me was my Chinon CS, two lenses (50mm f/1.7 and 28mm f/2.8), and a roll of Kodak 400TX.

Check all the photos on Flickr.

FlickrAPI and OAuth

Fri, 24 Feb 2012 08:17:11 +0100

This summer Flickr will stop supporting their old authentication system and move fully to OAuth. I’ve gotten several questions about whether Python FlickrAPI will support that. No worries, it will. If you want it fast, clone the repository, implement OAuth (don’t forget the unittests) and send me a pull request.

Joe McNally shows history of NG from 1992

Thu, 05 Jan 2012 14:05:23 +0100

One of my photographic heroes, Joe McNally, wrote a blog post looking back 20 years at National Geographic. He also has a video from back in 1992 about the process of National Geographic, from the photograph via editing, more editing, and then finally to print. It’s very cool to look at, if not for the story then at least for the hair.

I find it striking how much Joe looks like what I feel is a typical NY photographer back in the days. I would see him shoot alongside Peter Parker any day.

Play Framework

Mon, 21 Nov 2011 08:23:17 +0100

At the start of my last project by Chess IX (I’m leaving after working there for over 5 years) I looked at several Java web frameworks. One of the frameworks was Wicked, which I blogged about earlier, but the hands-down winner was the Play Framework. On the surface it seemed to be designed much like my beloved Django, and now that we’ve arrived at the final week of the project at my final week at Chess IX it seems like a good idea to write about my findings.

Overview of Play

Play is a full application stack, from the incoming HTTP request all the way to persistence, e-mails, scheduled jobs and dependency management. At the time of writing, version 1.2.3 is the current version.

The Play website already shows us 5 cool things we can do with Play, so I won’t repeat them here. Go check them out, they’re cool.

The HTTP cycle

Play has a very clear notion of a HTTP request-response cycle:

HTTP request for a certain URL comes in.
The routing table is consulted to determine the controller method that’s to be called. In our case this is a static Java method.
The controller method is called with the parameters from the request
The controller does its work, and results in a HTTP response.

By using a routing table, the URLs of the application are well defined. This has several advantages, for example bookmarkability of your pages.

Play compiles and reloads your Java code on the fly. It can determine by itself whether it should restart or not, and if it happens the restart is quite fast.

Another important feature is that Play is stateless. Anything that in other frameworks would be stored in server-side state is stored in client-side cookies (cryptographically signed to prevent tampering) or delegated to the database.

The automatic reloading, combined with the routing table, result in a very pleasant development flow. You can just hit F5 and your page including your code will be reloaded. This is quite different when using things like Tomcat or JBoss and more traditional Java frameworks.

Controllers

The routing engine delegates a HTTP request to a controller method. This is a static method in a subclass of Controller. Here is one controller class with two controller methods. The certificateId parameter comes from the request, for example when it ends in ?certificateId=123.

package controllers.admin;

public class Certificates extends SecureCHController {

    public static void showCertificate(@Required Long certificateId) {
        Certificate cert = Certificate.findById(certificateId);
        render(cert);
    }

    public static void redirectDemo() {
        showHistory(123);
    }
}

The controller class is dynamically altered in such a way that the showHistory(123) call results in a HTTP redirect to the URL that results in the showHistory call. The routing table is used to determine which URL the browser should be sent to. The resulting property is that the URL always reflects the displayed page. This dynamic alteration is done for all public static void methods, so if you want such a method but not have it altered that way, annotate it with @Util.

Debugging your controllers is very easy. You don’t need to restart Play, you can simply tell Eclipse to connect a debugger and you’re done. Now you can set breakpoints, step through code, view/change variables, etc.

Updating complex objects

Play has nice features for editing complex objects. Here is an example:

// the model in models/User.java
@Entity
public class User extends Model {
    public String firstName;
    public String lastName;
    public Integer numberOfPets;
}

// the controller in controllers/Users.java
public class Users extends Controller {
    public static void edit(@Required Long id) {
        User user = User.findById(id);

        if (request.method.equals("POST")) {
            user.edit("user", params.all());
            user.validateAndSave();
        }

        render(user);
    }
}

You would typically create a form like this:

<form action='@{edit(user.id)}' method='POST'>
    <input type='text' name='user.firstName' value='{user.firstName}'>
    <input type='text' name='user.lastName' value='{user.lastName}'>
    <input type='text' name='user.numberOfPets' value='{user.numberOfPets}'>
    <button type='submit'>Submit</button>
</form>

Because in the posted data the names match the properties of the User class, the user.edit(...) line updates the user object just like you’d expect.

Be aware that the controller has no knowledge of the form that was posted. Someone could forge a POST request that contains more properties than the original form. If you're not careful, users could raise their own privileges.

For example, if your User class has a Boolean isAdmin, then a POST could contain user.isAdmin=true. Without any modification, a user.edit("user", params.all()) call will happily set that isAdmin property.

Template engine

A lot of Java web frameworks are XML-centred. The reasoning behind it is that it’s easy to validate the templates. This is of course true, but of limited use

the validity of the templates doesn’t imply the validity of the produced HTML. The nature of XML also makes it difficult to stick to the DRY principle, as you’ll get constructions like below. This code tries to set class="secure" for HTTPS links, and class="insecure" for other links:

<c:if test='href.startsWith("https://")'><a href="<%= href %>" class="secure"><%= linkText %></a><c:/if>
<c:else><a href="<%= href %>" class="insecure"><%= linkText %></a></c:else>

Play uses Groovy as template language. With Groovy, the same concept would look like this:

<a href="${href}" class="#{if not href.startsWith('https://')}in#{/}secure">${linkText}</a>

With Play you can also template anything that’s not an element, such as part of a string or an HTML attribute. For example:

<link rel='stylesheet' href='{base_path}/style.css' type='text/css' />

This is impossible using Wicket without having to move the entire element to your Java code.

As you can see, you’re free to place your expressions right where you want them, without having to bother making the mix of HTML and XML valid XML. This is very important for modern sites, as HTML 5 is not XML.

Another upside is that you can use the same template engine for different content: XML, CSV files, mixed HTML and plain text e-mails, etc. Note that this also applies to JavaScript. With Wicket and other XML-based systems you cannot do this:

alert("Page title: {page.title}");

Referring to the URL that will call a certain controller method is very easy:

<a href='@{controllers.SomeController.javaMethod()}'>clickme</a>

Use @@{...} instead of @{...} to get absolute URLs, for example in e-mails.

Extending

Templates can “extend” each other, in a somewhat object-oriented fashion. A “parent” template can use a #{doLayout /} statement, which will be replaced by the contents of the “child” template. For example:

<!-- master.html -->
<html>
<head>
    <title>#{get 'title' /} - My Super App</title>
    <link type='text/css' href='https://stuvel.eu/style.css' rel='stylesheet'>
</head>
<body>
    <header>some header</header>
    #{doLayout /}
    <footer>some footer</footer>
</body>
<html>

<!-- page.html -->
#{extends 'master.html' /}
#{set title: 'This page' /}

<article>The content of this page</article>

It’s equally simple to create your own template tags. Just create a tags directory in the right spot, and place your tag files there. The tag files are simply HTML (or whatever you want) and the filename will become the tag name. Similar as #{doLayout /} template tags have a #{doBody /} that renders the template tag’s body. Here is a silly example:

<!-- tags/link.html -->
<a href='{_href}'>#{doBody /}</a>

<!-- usage in a template: -->
#{link href: 'https://stuvel.eu/'}my website#{/link}

I do miss some features in the templating engine, though. Django has “blocks” which you define in a “parent” template and can override in a “child” template. In the child you can also include the block content of the parent, so it’s very easy to add something to the parent, rather than replacing the entire block. I didn’t see this kind of flexibility in Play, but I must admit that I only looked at the default templating engine; other engines are offered as plugins.

Groovy

Groovy has many language features that Java lacks. Of course with Java you can do the same - it just takes more work. Here is a quick example in which we have a list of people, where each person has some eye colour, and we want to have a mapping from eye colour to the people with that eye colour. The script would look like this:

perEyeColour = people.groupBy { person -> person.eyeColour};

One could argue that grouping and sorting information is part of the presentation logic (rather than doing this at the database layer). The powerful way that Groovy can work with collections makes it a templating language that’s pleasant to work with.

For more information, check out the Groovy collections documentation.

Translations

Play has a simple yet quite effective translation system. It reads the file messages for all translations, and messages.nl if your browser tells the server you want Dutch, or messages.hr when you want Croatian (if you configure your server to support those languages, of course). Whatever it cannot find in these files it will take from the messages file instead.

AJAX integration

Play hasn’t got explicit AJAX support, but using AJAX is quite easy nonetheless. Returning a JSON response that serializes some object is as simple as:

public static void someMethod(Long personId) {
    Person person = Person.findById(personId);
    renderJSON(person);
}

Accepting POSTed JSON is similarly easy. Replace renderJSON with renderXml if you’d rather us XML.

As for the client side you’re free to use whatever tooling you like, such as jQuery.

Database layer

Hibernate is used as the DB layer, but with a slight twist. By itself Hibernate will persist all changes to a managed Java object, unless you explicitly prevent it. In Play changes to the Java object are always never persisted to the DB, unless you explicitly call someObject.save(). In this case I feel that explicit is better than implicit.

For simple queries Play created a simple language. Of course more powerful queries are possible as well, and Play will detect from the syntax whether the simple or more complex language is used. Here are some examples of the findBy(...) method:

@Entity
public class Profile extends Model {
    public User user;
    public String nickname;

    public static Profile findByNickname(String nick) {
        return find("byNickname", nick).first();
    }

    public static Profile findByUser(User user) {
        return find("byUser", user).first();
    }

    public static List<Profile> findActivatable() {

        String query = "select p from Profile p "
                + "where p.user is NULL "
                + "or p.user.activated = false";

        return find(query).fetch();
    }
}

The database interface is quite object oriented. Methods that we would traditionally create a separate Database Access Object (DAO) for, are simply methods on the DB object itself. Static methods are used for queries on groups, whereas non-statics are used for operations on single entities.

What I do miss is per-page query logging. When Django is running in development mode I can display the SQL statements and the time they took, right in the template. This makes debugging your SQL a lot easier. Something like this is also possible with Play of course, but requires you to go through a lot more steps configuring Hibernate, and then the logging still shows up in your log file, not on the page itself.

Property simulation

Many Javanians feel that you shouldn’t use direct property access. Instead you should write a getter and a setter method for the property. This often results in trivial methods that only clutter up your source. Sure, they can be automatically generated, but code is read more than it is written so readability counts heavily.

Play generates your setters and getters dynamically. Public properties will become private with public setters/getters, and all direct property access will use those. Any existing getters or setters you wrote because they actually have to do something more intelligent will be used by Play. So in this example, properties firstName and lastName will get trivial setters and getters, whereas the url property will use the hand-written setter and a dynamically generated getter:

public class PropDemo {
    public String firstName;
    public String lastName;
    public String url;

    public void setUrl(String url) {
        this.url = UrlLibrary.cleanupUrl(url);
    }
}

Because the getters and setters are generated, the objects are still compatible with the “java beans” concept, and thus can be freely passed to libraries that expect them.

I like this very much. It keeps my code clean, and increases information density on my screen: more functionality per line of code, with increased readability.

Authentication and authorization

Auth & auth is one of the areas where I’m less enthusiastic about Play. There is no built-in “user” class, nor groups, roles or rights. The login/logout controllers are tightly integrated with the rest of the security code, which makes it a chore if you want to have multiple login pages (for example using one URL for your users, and another for staff members).

Django does come with a “user” class and all the rest, proving that it’s very much possible to make a generic auth & auth system. Application-specific user properties are delegated to a “profile” model that you’re free to create yourself, so you don’t need to touch the built-in stuff. Very elegantly solved, and very missing from Play.

Play also has no template tags that help you with security, for example hiding links to pages that can’t be accessed by the user. The result is that you have to duplicate your access rules for the controller classes and the template engine.

Having said all that, once we had implemented the login system and defined the roles, it was quite easy to secure controllers. All we needed was something simple like this:

@With(controllers.Secure.class)
@Check("newsadmin|superuser")
public class NewsEditor extends Controller {
    ...
}

The @With annotation points to a class that checks the user’s access, and the @Check annotation describes the roles that are allowed to access the controller. You can also apply @Check to individual methods.

Dependency management

Dependencies are managed by Play too. They can be downloaded from the main Play repository, but it’s also possible to use one or more Maven 2 repositories.

Run play --deps to download the dependencies and install them in the modules directory. Add the --sync option to remove any old dependencies that may still be lingering around.

For my project we chose to commit those files to Subversion for a reason that was good at the time (I still support it but it’s no longer necessary due to an update). I now suggest you do not do this, as syncing the dependencies also removes the hidden .svn directories, making Subversion loose its temper (and its metadata). Of course this also applies to CVS. Mercurial and Git can handle this just fine, as they no longer have metadata in every directory (they have a top-level .hg resp. .git only).

Unit testing and CM-RC

The unit testing framework uses JUnit 4. You can subclass Play’s UnitTest class to run your tests in the Play context, or create a POJO for regular tests that don’t need the database etc.

By default the unit tests do not run transactionally. This was surprising, as I’m quite accustomed to that. This was fixed by creating an abstract TransactionalTest class containing the following:

@Before
public void createTransaction() {
    JPA.setRollbackOnly();
}

By calling JPA.setRollbackOnly() writes to the database are still allowed, but rolled back at the end of the transaction.

The test running isn’t restricted to unit tests though; it can also run Selenium tests. However, we decided against using Selenium in this way, as the Selenium tests flash by so quickly that you can’t see what’s going on. They’re gone faster than you can click the pause button. Instead we use Checkmate-RC for our front-end testing.

Code coverage measurements are possible using the Cobertura plugin. By running both your unit tests and front-end test in the same “play test” session you’ll get combined coverage reports. This is a lot easier than trying to get front-end coverage reports using Tomcat or JBoss.

Spring injection

There is a Play plugin for Spring, but it lacks automatic injection into the controller classes. My guess is that it’s due to the static nature of the controller methods. If your architecture heavily depends on Spring, it may not be a good idea to tightly integrate it with the Play framework.

A different approach (one that I quite like in theory, but haven’t tried yet) is to use a multi-tier system: Play for the front-end and a separate server for the Spring services / business logic. For the communication between those there is a plethora of RPC tooling.

Other front-end tech

During the project we used the following front-end tools:

jQuery for most of the JavaScript stuff. It makes cross-browser scripting a breeze, and easily extendible.
DataTables for more features for displaying tabular data.
jQuery-UI for date pickers, auto-completing text boxes, and other UI components.

The verdict

Above I’ve touched on the more important parts of the Play Framework. After working with it for a couple of months I’m quite pleased with it. The things that are meant to be simple really are simple, and we’ve noticed that adding more features to a webapp that’s been in development for months remains simple.

The different aspects of Play are cleanly separated. You can use it with another database layer, for example, or even without DB. You can swap out the templating engine if you like. Not only does this allow you to replace components with better alternatives, but it also indicates a good underlying design.

However, there are also downsides. The documentation is really good, but can be improved. The framework feels rather new, because there seem to be no Best Practices documented - there are multiple ways to reach the same goal, and they don’t tell you which is the best.

Some features also seem to be tacked on and left behind. For example, the play war command should give me a WAR file that runs on Apache Tomcat. I tried it, but it didn’t work. Posting to the discussion group resulted in no answer what so ever.

Adding auth & auth to the application also felt like it wasn’t really well thought out. The “security” module does its job, but is quite limited. Also the security warning I wrote above should have been in the Play documentation itself, but it’s painfully missing.

Having said all that, I would still recommend Play. It’s a pleasure to work with, bringing a lot of the features I was used to from Django into the Java world. Debugging is easy, the error messages are friendly and informative, and just pressing F5 to refresh is refreshing.

Play sticks closely to HTTP, rather than trying to reinvent the wheel, and I (mostly) kept feeling in control over the application. All the HTTP requests and responses are as designed, where other Java frameworks try to hide HTML and HTTP; I feel that knowing what is sent “over the wire” is part of the interface contract between client and server application, and as with every client/server architecture it is important to keep a grip over the communication.

Kudos to the people behind Play, and sincerely I hope that version 2 will be at least as appealing.

Photoshoot with Janet

Tue, 15 Nov 2011 14:45:18 +0100

A week ago my friend Janet asked for a photographer on Facebook. The next day she stood in front of me, modeling outdoors in Amsterdam. I had packed all kind of gear - digital camera, flashes, light stands, umbrella, reflectors, analogue camera, the whole shebang. Only I had forgotten to bring any memory cards… so I left all the digital stuff in the bag, and only used my trusty Chinon CS with Kodak Tri-X 400 film.

I got the negatives developed and scanned, and here are the results!

Gursky world

Tue, 15 Nov 2011 12:12:42 +0100

“when you’re looking with your eyes, it doesn’t mean you’re seeing.” – Andreas Gursky

The video below is a 23-minute documentary by Ben Lewis, about the German photographer Andreas Gursky. Lewis tries to find out what makes a Gursky a Gursky, and in the mean time learns about the man behind the photos.

Thanks to Stephen Schaub of The Figital Revolution for posting about this. Very inspiring!

My own dark room

Wed, 09 Nov 2011 12:50:39 +0100

This weekend I got a lot of dark room supplies from friends (thanks Ton & Q!). Monday I bought the necessary liquids, and yesterday I developed my very first photo. As soon as I saw the photo appear on the paper I fell in love with the process. Of course I wasn’t satisfied with the first result, so immediately I started playing around with dodging and burning. It was was easier than I expected, and very satisfying!

Right now my “dark room” is my bathroom, but I plan on changing that in a couple of weeks. We’re (still) renovating our attic, and when that’s done I’ll build a proper dark room there.

Hacking in Fallout 3 improved

Wed, 02 Nov 2011 12:08:03 +0100

Ever since I bought Fallout 3: New Vegas, I’ve been playing their hacking mini-game again. Of course I’m using my own hacking tool to help me. Today I made a small improvement: it now also suggests which words to try first. It picks the two words that are most different, and suggests you try those.

Check it out yourself!

I'm going to do a PhD!

Thu, 20 Oct 2011 07:41:55 +0200

Last Monday I went for a job interview at Universiteit Utrecht. Later that day I received a phone call from my to-be-promoter telling me I’m hired! So starting this December, my life will be radically different. I’m looking forward to it :)

Summer in The Netherlands

Wed, 31 Aug 2011 19:40:27 +0200

Here’s this year’s joke: summer. It’s like last spring was confused and acted all summery, and summer, autumn and winter all think they’re autumn.

Still makes for good photos though ;-)

Print Chuck

Sat, 20 Aug 2011 10:02:56 +0200

Panorama of Amsterdam Noord

Alex over at Print Chuck is using my FlickrAPI implementation on their website. He offered me a free print as a thank you note for writing the software! The print arrived yesterday, and it looks great. The paper is a thick cotton-based paper, which feels different from any other print I’ve had in my hands. It is super matte, just the way I like it!

UPDATE 2019: Their website seems to be down. The print still adorns our bedroom wall, though :)

360-panorama: Sint Bavo Church

Wed, 10 Aug 2011 15:40:06 +0200

Fokker, when he was 21 years old, flew a plane over Haarlem, around the Sint Bavo church. This photo was taken at the centre of that church. Take a look at the ceiling, it really is amazing! The photo is quite full of detail, so it won’t show its potential while it’s in this small window. Press the right-most button to see it in its full detail.

This photo is comprised of 80 individual photos, which were exposure blended and fused into this one (nearly) seamless shot.

360-panorama: Fokker Spin

Sun, 07 Aug 2011 17:06:16 +0200

UPDATE 2019: I have to fix the panorama viewer.

Fokker, when he was 21 years old, flew one of these planes over Haarlem, around the Sint Bavo church. Today it is exhibited in that very same church. Can you imagine never having seen a plane, and then this thing flying over your house? It must have been an amazing sight!

The photo is quite full of detail, so it won’t show its potential while it’s in this small window. Click the right-most button to see it in its full detail. And be sure to look up at the amazing ceiling too!

This photo is comprised of 83 individual photos, which were exposure blended and fused into this one seamless shot.

Python-RSA version 3.0 released

Fri, 05 Aug 2011 08:42:23 +0200

Python-RSA version 3.0 has been released. A lot of things have been improved:

Much more secure
Following industrial standard PKCS#1; this means compatibility with OpenSSL
Ability to create and verify detached signatures
More elegant method of encrypting large files
Ability to save and load keys in PEM and DER format
Extensive documentation
More efficient key generation

Check the Python-RSA page for more information!

Update: in the mean time 3.0.1 has been released, which removes an import of the “abc” module. This should make the code compatible with Python 2.5 again. All the documentation (including installation instructions) are the same as before.

My experience with Wicket

Fri, 29 Jul 2011 07:48:09 +0200

Today I found out that I’m not a Java programmer. The more I look at programming languages in general, the more I find Java to be clumsy and short-sighted. For a project at my work I tried Wicket.

A lot of web frameworks in Java have the “I’m scared by the web”-syndrome, in which they try to get rid of CSS and mostly JavaScript, and replace it all with Java. Wicket is no different in that respect. In my opinion, if you’re scared of the web, don’t build a web interface.

As an aside, a colleague pointed me to the Play framework. It appears to be very much like Django, but then for Java and Scala. I’ve given it a go, and it looks very nice!

Back to Wicket: my dislikes, in no particular order:

Bad examples & documentation

The few examples that they provide on their page don’t compile. You have to tweak them yourself in order to get things running, and then there are still warnings left. For example, they use:

Form form = new Form("form");

but that gives me a warning that the Form class actually requires a type parameter, like Form<Object>. The example doesn’t tell me anything about what this parameter should be, and more importantly gives me no links to more information.

The documentation also leaves a lot of things undocumented. You’re referred to the source code to see if there are any more examples in there. This is fine for new projects where they haven’t had the time to write proper documentation. However, this project has existed since 2004, so they’ve had 7 years to get this right.

No clear request-response cycle

You can do a lot with the HTTP headers: authentication, content type negotiation, language negotiation, status codes, and more. But to use those, you need access to the request and response objects. With Wicket, these are hidden away somewhere.

When wicket was initially developed it was seen as advantageous that the HTTP model was hidden. SOAP was all the rage, which was designed to be transport layer transparent (you could do soap-over-SMTP if you wanted to).

Nowadays we tend to look at more lean protocols, such as JSON over HTTP in REST-style, and Wicket doesn’t appear to be suitable for that.

Template language is (X)HTML and very thin

The Wicket template language works by extending the HTML DTD with more tags. This limits you to templating HTML. What about JavaScript? I want to do something like this, but it obviously doesn’t work:

alert("Page title: <wicket:message key='page.title'></wicket:message>");

I’m much more in favour of the Django template engine, where you could write:

alert("Page title: {{ page.title }}");

With “very thin” I mean that all you have in your HTML is some element with a wicket:id attribute:

<div wicket:id='somepanel'>placeholder content</div>

The only thing you can do now to figure out what’s going to happen when that’s rendered, is to dive into the Java code. I’d like the ability to add custom templates, so that the template HTML is more descriptive, such as:

<mytags:slideshow>
  <img src='https://stuvel.eu/image1.jpg' />
  <img src='https://stuvel.eu/image2.jpg' />
</mytags:slideshow>

There also doesn’t seem any way to template anything that’s not an element, such as part of a string or an HTML attribute. In Django you could do:

<link rel='stylesheet' href='{{ base_path}}/style.css' type='text/css' />

without having to move the entire element to your Java code.

Multiple URLs for the same resource

If you don’t create an explicit “BookmarkablePage” object for each page, they’ll get the URL /page_you_were_before?wicket:bookmarkablePage=:java.classname (I leave out the https://hostname part).

The result is that pages can have multiple URLs. These are two URLs that lead to the same page:

/page1?wicket:bookmarkablePage=:javapackage.Page3

/page2?wicket:bookmarkablePage=:javapackage.Page3

The URL that’s used by Wicket will depend on whatever page you were on previously, breaking the “visited” colour for links and the simple idea that a resource should have one URL.

Overly complex

Some things are just too complex. Look at this example on how to create a link:

add(new PageLink("pageLink", new IPageLink() {
    public Page getPage() {
        return new NonBookmarkablePage(PageLinkPage.this);
    }
    public Class getPageIdentity() {
        return NonBookmarkablePage.class;
    }
}));

Granted, the result is that a link to the current page is not clickable, which increases usability, and that’s a Good Thing. Still, from a coding point of view it’s ridiculously complex, compared to something like <a href='https://stuvel.eu/somepage.html'>link text</a>.

The good stuff

Sure, Wicket also has its good sides. The page inheritance model works quite well. And the links - once you get to implement them - are good too. As I wrote earlier, they don’t link to the page you’re actually on. The back button also keeps working, which is a rare thing in Java webapp land. And if Java is the only thing you’ll ever be interested in, but you still feel the need to write a web app, it may be very suitable for you.

Eclipse doesn't support AES-encrypted SSH keys

Thu, 28 Jul 2011 08:55:11 +0200

Today all of a sudden I couldn’t commit to CVS any more. Eclipse refused to accept my SSH key passphrase. When trying to load the file, Eclipse tells me ‘failed to decrypt id_rsa’.

I recently re-encrypted my private key using ssh-keygen -p, which used AES for the encryption. It turned out that Eclipse doesn’t support that.

The solution is quite simple: use openssl to re-encrypt using DES3:

cd ~/.ssh
openssl rsa -in id_rsa -out id_rsa-eclipse -des3
mv id_rsa-eclipse id_rsa</pre>

Please note that you may need to restart Eclipse, as it may cache your old key.

Lighting course a success

Sun, 17 Jul 2011 19:54:44 +0200

Today I gave my first lighting course, Strobist-style. As I’ve never done such a thing like that before it was a little unstructured. However, we were able to cover a lot of ground, and everybody went home feeling they had learned a lot. My friend Marc Faasse was friendly enough to let us rent his studio for the day, in the atmospheric NDSM Wharf in Amsterdam.

It was amazing to see how my students picked up on the techniques. They really enjoyed how their photos would come out better and better after each photo. I think I’ll do more of those courses in the future!

The students’ results

UPDATE 2019: Unfortunately those are all taken offline.

And here are some of my photos, modeled by Patric:

Originally this photo was 2:3 in “portrait” orientation, but I felt it suited a square cut much better. Speedlite 430EX at low camera right. Shutter at max sync speed to block out all available light.

This photo served as an example on doing whitebalance shifts. Speedlite 430EX with full CTO and black straw grid snoot from high camera left. Whitebalance set to tungsten to make the white background blue.

This photo shows whitebalance shifting as well as dragging the shutter and rotating the camera. Speedlite 430EX with full CTO gel, aimed at two pieces of paper stuck to the monitor. Picked 1/10 sec shutter to be able to easily move the camera.

Added random padding to Python-RSA

Sun, 10 Jul 2011 10:53:35 +0200

I’m thrilled to let you know that I’ve just added encryption and decryption with random padding to my Python RSA module. The code has become much more secure than it was before, and also makes it capable of encrypting and decrypting binary data! This is a big step towards the practicality of the implementation.

I’ve implemented the padding according to the PKCS#1 standard. The RSA Algorithm page by DI Management explains how to do this very clearly; cudos to them!

Right now these changes are unreleased. I want to add signing and verifying signatures too before I do that. Maybe I’ll deprecate the existing functions, as they are much less secure than all the new stuff I’m adding. If you want to try out what I’ve changed so far, feel free to grab a copy off my Mercurial repository.

UPDATE 14:20: I’ve also implemented PKCS#1 style signatures and signature verification

UPDATE 2011-07-12: the implementation is compatible with OpenSSL, making it very likely compatible with other implementations of PKCS#1 version 1.5!

Ilford Delta 3200

Tue, 28 Jun 2011 19:53:08 +0200

I fell in love with Fuji Neopan 1600 film, only to hear that it’ll be taken out of production soon (or already has been). Fortunately I could stack up on some rolls, but they’ll run out eventually. To find an alternative, I tried Ilford Delta 3200, which turned out to be quite nice too, although it’s a little too sensitive for my taste.

Happy cat is happy

Colin playing snooker

Marit playing snooker

All photos were taken with my Chinon CS camera and Auto Revuenon 55mm f/1.7 lens.

Stüvel Fotografie op Facebook

Sun, 19 Jun 2011 16:03:05 +0200

Ik heb een Facebook-pagina gemaakt voor Stüvel Fotografie: https://www.facebook.com/stuvelfotografie/

Deze keer een Nederlandse pagina – het blijft m’n moedertaal, en genoeg mensen zijn beter in Nederlands dan in Engels.

25 likes en ik kan er een betere URL aan geven ;-)

An early bird catches nice light

Wed, 15 Jun 2011 09:11:48 +0200

Some weeks ago I woke up early on a saturday morning. That’s nothing like me, as I love to sleep in late. But still, I wanted to catch the light glimmering off one of Holland’s largest canals and reflecting into the trees, and to get the right angle of the light I had to get there early.

This photo shows the relaxed atmosphere of the northern part of Amsterdam, while in the background there is the busy central train station. Be sure to check it out large.

De rust van Noord

A few hundred meters further north along the same canal I found this spot. Again the light reflected beautifully off the water. Everybody I met that morning was friendly, and there was a great atmosphere. I think this photo reflects that well.

Ochtendritje

Fotofestival Naarden

Sat, 04 Jun 2011 21:37:12 +0200

UPDATE 2019: The photo on Flickr doesn’t seem to be recognised as panorama any more.

Fotofestival Naarden was really awesome. The photos by Stephan Vanfleteren were amazing. He’ll be an inspiration for my future portraits. His photos (amongst other great photographers) were on exhibition in the Grote Kerk (large church) in Naarden. The atmosphere in the town was super relaxed, everybody was enjoying all beautiful photos and the lovely weather. I shot a 360° panorama at the front entrance of the church. Have a look around:

Drag your mouse to look up, down, left or right. Scroll to zoom. Double-click for full screen.

Photo hosted by Flickr

Awesome sheepies

Mon, 16 May 2011 11:05:52 +0200

Awesome Sheepies

We went shooting in one of the most beautiful and relaxing bits of the Dutch countryside. The photos didn’t quite work out as I wanted to – except for these two sheepies. They are teh awesome!

360 panorama: a day at work

Thu, 12 May 2011 19:08:59 +0200

Drag your mouse to look up, down, left or right. Scroll to zoom. Double-click for full screen.

This is the center part of my office building. I took some photos there today (84 in total), and stiched them together with Hugin. Post processing with Bibble Pro and ImageMagick.

Photo hosted by Flickr.

360 panorama, Amsterdam Noord

Wed, 11 May 2011 21:26:54 +0200

I’ve bought myself a Nodal Ninja 3 panorama head. Today I gave it a first test run, and it worked very well! That’s my bike, by the way ;-)

Drag your mouse to look up, down, left or right. Scroll to zoom. Double-click for full screen.

Photo hosted by Flickr.

This panorama was made up of 90 individual photos. I used exposure bracketing at -3EV, 0EV and +3EV to be able to handle the dynamic range of the scene. Stiching and HDR fusion was done with Hugin. To create the control points I used Autopano-SIFT, since I couldn’t really be bothered to manually align all those 90 photos. Once the points were created, I hit the Hugin “optimize” button, deleted all control points that had a distance over 30, optimized again, deleted control points with a distance over 10, optimized again, and let Hugin stitch the lot.

I’m happily surprised with the result! There are very few alignment issues, which is quite good for a fully automatic process.

The software I used was mostly Open Source. The only closed source bit was Bibble Pro, which I used to import the RAW images, apply some lens correction, and output as TIFF for Hugin.

Python serial comm and RTS pin

Fri, 29 Apr 2011 09:52:50 +0200

At my work I’m communicating with an embedded device via a serial-to-USB cable. It works fine, except for one little detail: when the “Ready To Send” (RTS) pin is high, the device shuts down. This is by design, but annoying nonetheless, since almost all serial communication software sets this pin to high. I’ve written a little Python program that opens the serial connection, sets the RTS pin to low, and shows all data read from it.

I’ve tested my solution on Linux, not sure if it works on other systems, as I’m using rather low-level calls to get the RTS pin low. Please leave a comment when you’ve tried!

The Python code defines two functions; one to set the RTS pin, and one to copy the data from the serial device to stdout. Here is the full code:

import fcntl
import struct
import sys
import termios
import time

def set_rts(fileobj, on_off):
    # Get current flags
    p = struct.pack('I', 0)
    flags = fcntl.ioctl(fileobj.fileno(), termios.TIOCMGET, p)

    # Convert four byte string to integer
    flags = struct.unpack('I', flags)[0]

    if on_off:
        flags |= termios.TIOCM_RTS
    else:
        flags &= ~termios.TIOCM_RTS

    # Set new flags
    p = struct.pack('I', flags)
    fcntl.ioctl(fileobj.fileno(), termios.TIOCMSET, p)

def output_data(filedev, ignore = '\r'):
    '''Outputs data from serial port to sys.stdout.'''

    while True:
        byte = filedev.read(1)

        if not byte:
            break

        if byte in ignore: continue

        sys.stdout.write(byte)

if len(sys.argv) < 2:
    device = '/dev/ttyUSB0'
else:
    device = sys.argv[1]

# Open device with RTS pin low
print 'Device: %s' % device
usb = open(device, 'rw')
set_rts(usb, False)

try:
    output_data(usb)
except KeyboardInterrupt:
    print 'Keyboard interrupt, closing.'

usb.close()
print '--- Done ---'

Analogue photography

Sun, 24 Apr 2011 23:07:01 +0200

Sheep Number 61

Ever since I got two old cameras for my birthday last year, I’ve been drawn more and more towards analogue photography. You know, the kind that involves negatives and chemical processing, and where you don’t have to worry about getting dust on your sensor. There is a certain mistery in not knowing how the photo will turn out to be. There really is a thrill in cycling to the photo store and looking at the negatives on their light table. Also I seem to stay more “in the flow” while shooting, rather than breaking it by inspecting the LCD display. This worked very well for the shoot with Selina. And finally I just love the look of real black & white photos made with old optics!

There are downsides, of course. The major one is that it seems to be impossible to scan an entire negative without having one or two cat hairs on them…

My photo gear page hasn’t been moved to my new site yet. For those who are interested, this is the analogue gear that I actively use:

Meopta Flexaret IV: A twin-lens reflex camera from the 1960's; it was built somewhere in 1961-67. It eats 120 film and makes square photos. It has two 80mm lenses; one to look through and one to make the photo with.
Chinon CS: A 35mm SLR built in 1979. I mostly use it with an Auto Revuenon 50mm f/1.7 lens and a Chinon 28mm f/2.8.

Film-wise my favourite is Kodak Tri-X 400. It has a nice contrast and grain; I just love the look! If that isn’t available, I shoot with Ilford HP5+ 400. Still have to make up my mind about those two; I haven’t shot enough of either to really have a strong opinion one way or the other.

Relax/yoga/detox/reiki-weekend

Fri, 08 Apr 2011 15:34:27 +0200

Reiki-weekend Lighthouseworks

Marit and I went to a relax/yoga/detox/reiki-weekend organized by a friend of ours. It was very special, very relaxing, and also a bit mustle pain inducing. A while ago Marit found a 15 year old roll of 35mm negatives, which I used to shoot some photos during the weekend. They turned out to be quite nice!

To the photos!

Graffitti @ Mosveld

Tue, 22 Mar 2011 19:59:12 +0100

Graffiti bij Mosveld

Een groep van 36 kunstenaars uit 6 landen zijn bijeen gekomen om onze stad op te fleuren. Op dit moment werken ze in Amsterdam Noord bij het Mosveld.

Natuurlijk kon ik het niet laten om wat foto’s er van te schieten.

Version 2.0 of RSA module

Sun, 09 Jan 2011 16:51:53 +0100

A guy named Dave sent me an email today, telling me that my RSA implementation was rather insecure due to the use of the “pickle” Python module. Fortunately I had some nice improvements by Barry Mead already in version control, eagerly waiting to be released. Well, Dave gave me a nice insentive to round up Barry’s improvements and send version 2.0 into the world.

Please note that it’s a backward-incompatible change. The RSA page shows how you can re-encrypt your data to be compatible (and more secure!) again.

New website

Wed, 24 Nov 2010 23:55:51 +0100

My old website has been online for april 2006. Since that time it has grown considerably. My focus also moved from software engineering to photography, and this new design makes that a lot clearer. Some of the webpages may not yet be available. Don’t worry, most of it will be ported in the next few weeks. If you’re missing something, let me know and I’ll give it priority.

I’ve also put the photos online of a photoshoot with model Selina. This was the first time for me doing a model-shoot with my old Flexaret IV twin-lens reflex medium format camera. I must say I’m very pleased with the result! Having only 12 frames on a roll is a nice break from shooting with a 7 FPS digital SLR.

Mijn foto's op Caro Emerald DVD

Tue, 02 Nov 2010 12:34:16 +0100

Caro Emerald in Hoogwoud

Caro Emerald komt met een platinum release van haar CD Deleted Scenes from the Cutting Room Floor, met daarbij “een overvolle dvd met extra video-, audio- en fotomateriaal”. Jawel, ook mijn foto’s! Helemaal te gek :)

Naast zo’n DVD hier in Nederland komt er ook een zelfde soort DVD uit in Polen, waar mijn foto’s ook op gebruikt gaan worden!

Je kan de DVD al pre-orderen op bol.com

Tentoonstelling in Noorderpark

Sun, 17 Oct 2010 18:06:55 +0200

UPDATE 2019: Helaas is de Noorderpark website down.

Speciaal voor Crisiskunst in het Noorderpark heb ik een foto gemaakt, die nu in de Noorderparkkamer hangt. Elke zondag zijn hier interessante dingen te beleven, gratis en toegankelijk voor iedereen.

Deze foto heb ik geschoten in Haarlem. Het is een monumentaal gebouw, en heeft daardoor een tragisch verhaal. Vanwege het label “monumentaal” wordt het niet afgebroken, maar het kost ook zo veel om op te knappen dat dat ook niet gebeurt. Voor mij was het een mooi beeld van het thema crisis.

De foto is gemaakt met een Meopta Flexaret IV, een middenformaat tweeogige spiegelreflexcamera uit de jaren ‘60, deze zomer gekocht in Praag, Tsjechië. De film was Kodak Tri-X 400, de afdruk is ruim 40x40 cm op mat papier.

Op zondag 7 november worden de foto’s geveild. De fotografen die hieraan meewerken zijn: Caro Bonink, Yvonne Witte, Annelore van Herwijnen, Liza de Rijk, Maaike Koning, Marc Faase, Diana Scherer en Sybren A. Stüvel.

Voor meer info zie Crisiskunst - Kunst met de grote C. en Crisiskunst 3

Een quootje over de crisiskunst:

Kunst in tijden van crisis gaat over ondernemerschap en creativiteit. Hoe maak je kunst zonder subsidie? Bedrijven worden gevraagd hun afvalproductie in te leveren om kunst van te maken, (straat)muzikanten worden uitgenodigd om in het park te musiceren, fotografen van Noord leggen de crisis op beeld vast en de foto’s worden geveild in het park. Crisiskunst organiseren we samen met Stichting Kunstenaars&CO. Kunstenaars krijgen de opdracht om gedurende zes weken een project te realiseren zonder subsidie, op z´n Berlijns.

I fixed my camera!

Sat, 25 Sep 2010 11:50:51 +0200

In Prague I bought an old Flexaret IV, a twin-lens reflex camera from the 1960’s. I was very happy with it, until it gave a short “click” even with a shutter speed of 1 sec. The shutter refused to open! When I developed the film it was clear that when I bought the camera it was still in working condition, and it had also survived the trip back to Amsterdam. After some messing about with a screwdriver and the moving bits of the camera I found out that the self-timer was stuck. Moving some pins around got it un-stuck, and so I have a working camera once again!

The camera refuses to work when it is closed but has no film in it. One thing I figured out while toying with it, was that it does work properly without film when the back has been opened. So if you’re unsure whether to buy such a camera and you want to give it a try without wasting film, just open the back.

I'm a Master of Science!

Thu, 02 Sep 2010 14:42:15 +0200

Yesterday I received my certificate from the Utrecht University! I’m now officially a Master of Science or Magister Scientiæ in Computer Science.

Extending Selenium from the client driver

Fri, 20 Aug 2010 07:40:00 +0200

Selenium is a web page testing tool that we use a lot at my work. It can be extended by supplying it with a user-extensions.js file.

We’re extending our test application to include support for Selenium Grid. In this setup we can’t supply that user-extensions.js file directly, it has to be injected via the client driver. However, this happens too late; Selenium doesn’t notice our custom locator functions any more. This is a known issue, also noted by Ross Patterson. I’ve found a way to work around this limitation. Add the following to your user-extensions.js file such that it’s executed after your additions have loaded:

objectExtend(selenium.browserbot, PageBot.prototype);
selenium.browserbot._registerAllLocatorFunctions();

It seems to work just fine without any unwanted side-effects. If you tried this, please leave a comment to let us know how it worked out for you!

360 panorama: Amsterdam Central Station

Tue, 20 Jul 2010 16:13:02 +0200

UPDATE 2019: check out my other panoramas on stuvelfoto.nl!

This panorama shows something that I quite often see; the people here are waiting for the ferry to cross the IJ (the lake that separates the northern part of Amsterdam from the rest).

Look around by dragging, use your scroll wheel or page up/down keys to zoom. Double-click to view full-screen.

This photo is hosted by Flickr.

This time I used Hugin for remapping and aligning the photos, but I merged them by hand in The Gimp. It’s quite an easy process, and it gives you much more control. I took the photos without a tripod or any other form of support, so not everything lined up perfectly, which is where the manual control came in handy.

Sigma 4.5mm Fisheye - What's it like?

Mon, 28 Jun 2010 09:14:00 +0200

Sigma 4.5mm f/2.8 fisheye by Sybren A. Stüvel, on Flickr

This lens is insane. It’s the world’s first circular fisheye lens for APS-C sized sensors, and the first fisheye lens that I own. Looking through the viewfinder for the first time was a strange sensation. The view was both very restricted due to the circularness of the lens, and very wide at the same time due to its 180 degree view all around. For those not intimate with fisheye lingo, “circular” means that it projects a circle on the sensor. Outside of the circle everything’s black, inside the circle you have a 180 degree view from left to right, and top to bottom. So far the best us APS-C shooters could get was a “diagonal” fisheye, which means that you only get a 180 degree view from top left to bottom right. Horizontal and vertical would be less than 180 degrees.

Yellow Volkswagen van

From the first moment I saw the lens I knew that I just had to have it…. the only downside is the price tag. At €650,- it’s not the cheapest of lenses, but it’s not that insane compared to other fisheyes. Sigma isn’t known for their good quality control. The shop I bought the lens at had three of them in their magazine, and the first two had uneven coating on the front element. The store personnel told me that it wouldn’t show on photos, but nevertheless they let me inspect all three lenses, and one of them had perfectly even coating. For that price, I wanted to make sure I got the best one.

I used the lens on my Canon EOS 7D, so besides having a high resolution of 18 megapixels I could also give it a go with video. And boy is it fun! I don’t have a professional setup where I can measure things like distortion or colour metrics. Instead I’ll tell you about practical results I got with this lens, and how they look with my two eyes. The photos you see here are also processed a little bit. Unprocessed photos from a digital camera always look a bit flat and soft, so I don’t think that presenting you with such photos would be a true demonstration of the capabilities of this lens.

The lens

Sigma 4.5mm f/2.8 fisheye by Sybren A. Stüvel, on Flickr

The lens feels very sturdy. The build is solid, and with a metal mount it attaches firmly to the camera. At the rear there is a gelatine filter holder, and you even get a small metal plate you can use to cut the filters to size. I feel that this filter holder is of limited use, unless you want to insert ND filters. As the holder doesn’t rotate you can’t really use polarizers or graduate ND filters.

Going further towards the front of the lens, we meet the distance scale. It has three marks: 13.5cm, 20cm and infinity. Remember these distances are measured from the sensor; it can focus really, really close. The hypersonic motor (HSM/USM/whatever you want to call it) does its work quickly and silently. The focus ring is all the way at the front, and rotates smoothly. I would have liked it to be a bit further backward, though. My hands are quite big, and it’s just too easy to get some digits into the frame. Every bit of finger that sticks out from the focus ring will get photographed, so be careful with that.

The front element bulges out of the lens, to be able to capture the 180 degree view. The lens cap comes with a metal ring so that it can fit around it. So, remember to remove the ring as well as the lens cap, or you won’t get the full view.

The maximum aperture is f/2.8, which is a tad slow for a prime but quite good for a lens this wide. Combined with the short minimum focus distance you can even use it to blur the background. A little. The wide aperture is more useful for low-light shots; it also means that the viewfinder is bright, and that your autofocus has more light to work with.

The photos

The centre sharpness of this lens is amazing. Even at very close range - which is where you want to be with a lens like this - it is very sharp. Towards the edges it has some serious chromatic aberration and purple fringing in high-contrast areas. As it’s my first and only fisheye lens I can’t tell you whether this is more or less than others. I just know that it’s very difficult to bend light and keep all the colours where they should be, and at the edges that light is bent a lot. The photo below has been corrected, the photo of the Volkswagen van up top hasn’t been.

Close-up of Marit

The lens flare looks really nice, as it doesn’t stick to the circular projection

it breaks the frame, so to speak. Of course if you don’t like it you can always mask it during post processing. The flare shows that the aperture has six blades. I would have liked one more - I like odd flare streaks more than even ones. The aperture makes more noise that I would have expected; more than any other lens that I own. Now this isn’t a lens you can use stealthily anyway, as you’ll have to get right on top of the action or it’ll get really, really small, so a bit more aperture noise isn’t a practical issue.

The Panoramas

The wide view makes this lens very suitable for panorama shots. With only two photos you’ll be able to capture the entire view around you. However, you won’t be able to stitch them together very well; at the edges the quality goes down, and there wouldn’t be much of an overlap anyway. So rather than using the minimum, I used six shots: north, east, south and west, and straight up and straight down. And since I was shooting a library with mostly black architecture and large windows with a bright sun outside, I tripled every shot at -2 EV, 0 EV and +2 EV to merge them later as HDR photos. The 7D with its 7 photos per second just whirred through those three shots per direction.

The panorama is hosted by Flickr. Double-click to view full-screen, drag to look around.

Before I started stitching the photos I loaded the RAW files into Bibble Pro 5.1 and removed most of the chromatic aberration (C/A). With a few clicks the C/A was as good as gone, and since I had a nice overlap between different shots the remaining C/A wouldn’t pose any problems. The 18 RAW files were exported to 16-bit TIFFs (100 MB a pop) and then loaded into Hugin.

In Hugin I manually placed control points, about 5-7 per overlap, optimized the photo and let it do the stitching and HDR processing. Hugin is very good at producing realistic HDRs. Many HDR programs first create a photo with a huge dynamic range and then try to compress this range using tone mapping. This can easily produce those super-saturated, artificial looking photos. Hugin blends between “real” pixels, ignoring ones that are under or over-exposed, blurry, etc. and keeping the good looking ones. This process gives a much more natural result.

After exporting the photo in “equirectangular” projection, I loaded into the Flash application by pan0.net so that you can look around in it. The zenith (look straight up) isn’t perfect yet, but I’m sure I can fix that if I spend enough time on it. Also know that I took those photos without any tripod or panorama head.

The videos

The lens is nearly perfect for video. The video below shows a view from my Renault Twingo. The music is by my band (I’m the drummer) The Soundabout, and the drive is from our practice studios to my home. Click on the cross-like thingy at the bottom of the video to view full screen.

So yes, it’s good but just not quite perfect for video. It’s more an issue with my 7D than the lens, to be honest. At those lovely modern and crispy 16:9 HD resolutions the camera crops a few pixels off the bottom of the circle - I would be much happier if we would have gotten a true 3:2 high-resolution video format, so that the entire frame could be captured. So Canon, if you’re reading this, pretty please with sugar on top, add a 1920x1280 or 1620x1080 video format!

As I said, I drum in a band. My girlfriend sometimes records our performances on video, and will of course start using the Sigma fisheye lens for this. Keep an eye on our website!

The verdict

Sigma 4.5mm f/2.8 fisheye

This lens is unique. The results are very pleasing, and most importantly: it’s great fun. It’s really different from anything else in my photo bag. The price is a bit steep, but given the quality and the fact that they won’t sell that many of them, I think it’s justified. If you want to easily shoot 360 panoramas, record edgy videos or otherwise use an incredibly wide field of view, this lens is for you.

This article was also published on Digital Photography School.

Graduated as MSc!

Wed, 23 Jun 2010 14:42:14 +0200

Last monday I defended my thesis and succeeded! I got an 8.5 (out of 10) as the grade, with which I’m very happy. This finalizes my Game & Media Technology computer science master at the Utrecht University.

The title is Stride Space: Humanoid walking animation interpolation using 3D Delaunay databases.

Abstract:

Precise control over foot placement during character locomotion is crucial to avoid obstacle collision and to produce natural results. We present a new exact parameterization technique for generating humanoid walking animations. Given a database of pre-recorded motion capture data we generate new animations using a spanning neighbours search in a Delaunay database and interpolating those neighbours. Our approach results in exact foot placement while soft constraints such as timing are also taken in account, due to a novel blend candidates selection strategy. We show that this can be done very efficiently as to be compatible with real-time applications.

You can download my thesis from https://stuvel.eu/files/publication/stride_space.pdf

Multiple instances of QApplication in one process

Sat, 22 May 2010 09:25:40 +0200

I’m working on a PyQt 4 application for my employer Chess. Of course I’m writing plenty of unit tests for it as well. Those tests have to be cleanly separated from each other, so every test that requires the entire application to be up and running should have its own instance. And this is where it gets tricky, as Qt (and thus PyQt) assumes that there will only be one application, and if that application quits the process quits.

In my unit tests, this is not the case. Every test can potentially start and stop an application, and the test suite will continue running. This caused a segmentation fault (a.k.a. segfault) the second time the QApplication closed.

After a lot of puzzling I found out that QtGui.qApp needs to refer to the running QApplication instance, and be set to None when the application has been closed. After I implemented this the segfaults went away.

This is my ApplicationTest mix-in class that I use for controlling my application lifespan. It contains a little trick to stop the application as soon as it has started:

class MyApplicationClass(QtGui.QApplication):

  started = QtCore.pyqtSignal()

  def exec_(self):
      self.started.emit()
      return QtGui.QApplication.exec_()

class _ApplicationTest(object):
  '''Mix-in class that can start and stop an application.'''

  APP_CLASS = MyApplicationClass

  def __init__(self):
      self.app = None
      QtGui.qApp = None

  def create_app(self):
      '''Creates and returns a new application'''

      self.app = self.APP_CLASS([])
      QtGui.qApp = self.app
      return self.app

  def stop_app(self):
      '''Stops the application.'''

      if not self.app: return

      self.app.started.connect(self.app.quit,
              type=QtCore.Qt.QueuedConnection)
      self.app.exec_()

      QtGui.qApp = None
      self.app = None

Strobist meeting

Mon, 19 Apr 2010 09:08:52 +0200

Yesterday Ork and I went to a Strobist meeting in Breukelen, The Netherlands. We had a lot of fun, joining 18 photographers and 16 models, in an old abandoned industrial building. Fervently used by graffiti artists and as an illegal dumping site for tires it was quite a nice setting.

Browse through the set.

Most photos of the meeting can be found in the Dutch Strobist pool and all should be tagged too.

Stop-motion: Drunkard

Tue, 13 Apr 2010 05:37:10 +0200

Hey folks,

I’ve made my first stop-motion animation! And it’s also my first video on Flickr. Well, video - let’s just call it a concatenation of frames. I’ve enjoyed making it, I hope you enjoy watching.

The video consists of 66 frames, shot with my Canon EOS 7D and Canon EF 85mm f/1.8 USM lens. The light comes from a gritted 430EX strobe, and the 1/250 shutter speed ensures the ambient light was invisible.

Updated my portfolio

Sun, 14 Mar 2010 12:23:05 +0100

UPDATE 2019: the website linked below has been replaced by stuvelfoto.nl.

I’ve just updated my portfolio so I invite you all to take a look!

Bloody Marit

Sat, 20 Feb 2010 11:14:58 +0100

Bloody Marit II

This photo was made in an old ship factory in Amsterdam Noord (the NDSM Wharf). We picked a suitable old and faded green wall as the background, set up the lights, and started shooting.

The key lights are two Canon Speedlite 430EX strobes. They were pointed up into tall U-shaped corrugated cardboard sheets that were lined with aluminium foil to form DIY strip lights; both strobes were set to 1/4 power. The fill light was provided by a Speedlite 580EX-II at 1/16 power through a shoot-through umbrella.

I shot with my Canon EF 85mm f/1.8 USM on a Canon EOS 7D. The 1.6x crop factor makes this a very nice portrait lens. The aperture was f/8 to get sufficiently deep depth of field and sharp results, and the shutter speed of 1/250 second ensured that no available light got onto the sensor.

Setup shot for Bloody Marit

Here is a wide shot that shows the setup. I used the 7D as the master, and I was surprised how well it worked. Because I used my 85mm f/1.8 I could move back a little (compared to my standard 17-55mm zoom), which made the slave strobes more into the “field of view” of the popup flash. The 430EX’s “looked” at Marit instead of my camera, so I added some aluminium foil to bounce the master flash into their IR sensors.

Thank you for reading!

Song title fades in AfterEffects

Wed, 10 Feb 2010 23:04:08 +0100

I’ve been working on a video of our live performance in Winston Kingdom using Adobe AfterEffects. To show the title of a song at the start and end of the song, I used a script to automate the fading. Assign it as an expression to the opacity of the text layer and it’ll automatically show for a few seconds at the in-point and out-point of the layer, including nice fades:

fade_time = 1
show_time = 5
if (time < inPoint + fade_time) {
    linear(time, inPoint, inPoint + fade_time, 0, 100)
} else if (time < inPoint + fade_time + show_time) {
    100
} else if (time < inPoint + fade_time + show_time + fade_time) {
    linear(time, inPoint + fade_time + show_time, inPoint + fade_time + show_time + fade_time, 100, 0)
} else if (time < outPoint - fade_time - show_time - fade_time) {
    0
} else if (time < outPoint - fade_time - show_time) {
    linear(time, outPoint - fade_time - show_time - fade_time, outPoint - fade_time - show_time, 0, 100)
} else if (time < outPoint - fade_time) {
    100
} else if (time < outPoint) {
    linear(time, outPoint - fade_time, outPoint, 100, 0)
} else {
   0
}

fade_time is the duration of fade-in and fade-out, show_time determines how long the text layer is shown at 100% opacity, both are in seconds. You can make an animation preset by adding a “Solid Composite” effect, setting opacity=0% and assigning the expression to the “source opacity” property.

Python Flickr API 1.4 released

Wed, 03 Feb 2010 16:50:20 +0100

The Python FlickrAPI kit has just been released. The new features are:

Using auth_callback=False when authentication is actually required now ises a FlickrError exception.
The implementation uses self.flickr_host so that subclasses can override e API URLs.
Support for short URLs was added.

Of course the Python FlickrAPI kit is completely dynamic, and so it always supports any new FlickrAPI functionality as soon as it is released by the Flickr team.

The new version can be found at https://stuvel.eu/flickrapi or the Python Package Index at https://pypi.python.org/pypi/flickrapi

Holiday Special: Sausage

Thu, 24 Dec 2009 13:21:23 +0100

Holiday Special: Sausage

What are you looking at? It’s a sausage. “Rookworst” (a type of smoked sausage), to be exact, probably well known to every Dutch reader. It was hand-made by my parents’ butcher and wrapped with some Christmas fluff, also by the butcher. He handed them out as Christmas presents!

Before we go on the the specifics of this shot, first a few acronyms:

CTO: Colour Temperature Orange, makes the light warmer.
CTB: Colour Temperature Blue, makes the light colder.
ND: Neutral density, makes the light darker.

The key light from high camera right is a 580EX-II, 1/2 CTO gel, double gobo’d so that it illuminates the sausage thingy and not the background, at 1/4th power. The fill light from camera left is a 430EX-II with a DIY white diffuser and a full CTB gel. The third light is a 430EX behind the sausage, at 1/128 power, with a red gel for the effect and a 2-stop ND gel to make it subtle enough - 1/128 power is as low as it goes, but that was still too bright.

I chose to work with CTO and CTB gels to add some contrasting colours. The gels are balanced, which means that where the warm and cold light meet they form white light again. This makes for some subtly coloured shadows, where only one light shines and the other is blocked. I chose 1/2 CTO and full CTB because it just looked better - with a full CTO the colours would become too orange.

Here you see an incremental buildup of the three lights (click for a larger version):

The making of Holiday Special: Sausage

It's really winter

Sun, 20 Dec 2009 19:03:09 +0100

Jojo in the snow

Well waddayano, even with all the global warming we can get a few days’ worth of real winter in The Netherlands. Clogged up public transportation, taking corners sideways with our car, and a beautiful white world.

Photos

Duplicating audio with ALSA

Fri, 11 Dec 2009 08:35:14 +0100

On Linux the most used sound system is the Advanced Linux Sound Architecture, ALSA for short. It’s a very configurable system, but it’s not easy to dig down far enough to get to its power.

What I wanted to do was to get the same music in the living room and the computer room. The rooms are right next to each other, and my desktop is sitting with its back towards the living room. My desktop has two audio cards, one built-in VIA-82xx and my trusty SB Audigy. All I had to do hardware-wise was to connect the VIA-82xx to the amplifier in the living room and the Audigy to the amplifier in the computer room.

But then came the tricky part - to have one application send its sound to both cards simultaneously. You can configure this on a per-user basis in ~/.asoundrc or globally for the entire system in /etc/asound.conf. It takes two steps:

Create a virtual “sound card” that has four channels. Channels 0 and 1 will be sent to one sound card, and channels 2 and 3 will be sent to the other.
Create a routing “sound card” that mixes its stereo input to the quad-channel virtual sound card.

Place this into ~/.asoundrc or /etc/asound.conf:

# This is the four-channel card that sends its first two channels
# to one real card, and the other two channels to the other card.
pcm.tworooms {
    type multi;
    slaves {
        a {
           # The first real card, change to "channel:CARD=CardName"
           # for your system.
            pcm "front:CARD=Audigy";
            channels 2;
        }
        b {
           # The second real card, change to "channel:CARD=CardName"
           # for your system.
            pcm "iec958:CARD=VT82xx";
            channels 2;
        }
    }

    # This configures how the four channels of this virtual
    # card are distributed amongst the real cards.
    bindings {
        0 { slave a; channel 0; }
        1 { slave a; channel 1; }
        2 { slave b; channel 0; }
        3 { slave b; channel 1; }
    }
}

# This virtual "sound card" mixes two channels up to four.
pcm.both {
    type route

    # Its four-channel output is sent to the "tworooms" device.
    slave {
        pcm "tworooms"
    }

    # This defines how the channels are mixed. Input channel 0 is
    # sent for 100% to channels 0 and 2 of device "tworooms",
    # and its channel 1 is sent for 100% to channels 1 and 3.
    ttable {
        0 { 0 1.0; 2 1.0 }
        1 { 1 1.0; 3 1.0 }
    }
}

So far so good. Now I want surround sound. Unfortunately, when I change slave “A” to surround51:CARD=Audigy and increase its channels to 6 (updating the bindings accordingly) it refuses to work. MPlayer tells me The number of output channels must be between 1 and 6. Current value is 8.

If you know how to solve this, please let me know. ALSA should support more than 6 channels, as demonstrated in the ALSA wiki.

New PGP key

Mon, 26 Oct 2009 22:20:03 +0100

I have superseded my old key with a new PGP key. Please import the revocation certificate for the old key and the new key.

Python Flickr API 1.3 released

Sat, 03 Oct 2009 02:20:56 +0200

Today I released version 1.3 of the Python Flickr API. It’s clear that I’ve been busy with my study and my work, as the world hasn’t seen a release in nearly a year. This is mostly due to the dynamic nature of the code - it automatically adapts to any new functionality that’s added to Flickr, so no release is required then. This release adds some nifty new things:

Added functions to easily walk through sets and search results, querying Flickr no more than needed.
Uses the hashlib module, falling back to the md5 module when hashlib is unavailable.
Added locking token cache, in case a Flickr API key is used by multiple processes at the same time on the same machine (or shared filesystem)
Removed the deprecated fail_on_error parameter.
Implemented the auth_callback functionality.

Go to the Python Flickr API.

Why doesn't Windows have a package manager?

Mon, 14 Sep 2009 22:59:37 +0200

After I uninstalled Visual Studio 2005 Pro I got this very long message (I’ve included it at the bottom of this blog post) telling me to manuall uninstall twenty other programs, in the correct order.

They are capable to install all of this with one single button. Why on earth are they incapable of removing this? Why do I have to remove those programs myself? I’m also fairly sure that I can’t even keep the window open so that I have a reference, because it is an installer and thus locks some DLLs that need to be uninstalled too.

Yes, replacing in-use files. It’s a thing that systems all over the world have been capable of doing for years. Microsoft is still unable to do this nifty little trick that’s oh so useful.

You may wonder why I want to remove Visual Studio in the first place. Well, an update of Internet Explorer broke some programs, so now I’m trying to repair my installation of Visual Studio. The built-in “Repair” function didn’t work, without telling me why. So now I’m back to manually having to remove and reinstall every little part.

Please, Microsoft, join the new millennium and start using a package manager like all those Linux distributions have been doing for years. They don’t use a package manager to tease you. They use a package manager because it’s bloody useful.

Update: after hours of waiting while my computer uninstalled and reinstalled everything, it still didn’t solve my problem. Snif.

The message read:

Uninstall is complete.

Next Step: Uninstall additional components

Additional components might have been installed on your computer by Visual Studio during setup. These components must be manually uninstalled using Add or Remove Programs in the order listed below.

Note: Uninstalling these components might affect other applications you have installed that rely on these components.

The following components might have been installed with Visual Studio:

Microsoft MSDN 2005 Express Edition

Microsoft Visual Studio 2005 Tools for Office Runtime Language Pack

Microsoft Visual Studio 2005 Tools for Office Runtime

Microsoft Device Emulator version 1.0

Microsoft .NET Compact Framework 1.0

Microsoft .NET Compact Framework 2.0

Microsoft SQL Mobile 2005 Development Tools

Microsoft Visual J# 2.0 Redistributable Package

Microsoft Visual J# 2.0 Redistributable Language Pack

Microsoft Document Explorer 2005

Microsoft Document Explorer 2005 Language Pack

Microsoft Data Access Components 2.8 SP1 (Windows 2000 only)

The following components might have been installed with SQL Server Express, and need to be removed in the order listed below:

Note: Uninstall of the SQL Express instances will leave behind the user-created databases, which can then be re-attached to the new instance.

Microsoft SQL Server 2005 Express CTP

Microsoft SQL Server 2005 Express Tools CTP

Microsoft SQL Server Setup Support Files

Microsoft SQL Native Client

The following components must be uninstalled last:

MSXML 6.0 Parser and SDK (only on 32bit)

MSXML 6.0 Parser and SDK x64 (Only on 64bit)

Microsoft .NET Framework 2.0 Language Pack

Microsoft .NET Framework 2.0

Removing duplicate mails

Tue, 08 Sep 2009 09:53:09 +0200

To sync my mail between computers I use offlineimap on a secure filesystem. Today I mistakenly ran offlineimap before mounting the secure filesystem, which caused it to duplicate all emails. Not wanting to do any manual work to fix this, I wrote a small Python 3 program that repaired the damage.

import mailbox
import glob
import os.path

def dedupe(maildir):
    '''Removes duplicates from the given dir'''

    box = mailbox.Maildir(maildir, create=False)
    box.lock()

    seen = set()   # Set of Message IDs we have seen
    delete = set() # Set of message keys to delete

    # Search for messages to delete
    for (key, message) in box.iteritems():
        mid = message['Message-Id']

        # If we have seen this Message ID before,
        # remember it for deletion
        if mid in seen:
            delete.add(key)

        seen.add(mid)

    # Delete the messages
    for key in delete:
        box.remove(key)

    box.close()

# Iterate over all subdirectories as maildirs
for dir in glob.glob('*'):
    if not os.path.isdir(dir): continue

    dedupe(dir)

I just put this here so I wouldn’t lose it. Perhaps you find some use for it too.

The current state of Big Brother

Wed, 22 Jul 2009 21:32:31 +0200

Big Brother is watching you. More and more invasions of your rights are done in the quest for “digital rights management” and “protection of intellectual property”. Check out Farhad Manjoo’s post Why 2024 Will Be Like Nineteen Eighty-Four, as he describes it much better than I ever could.

UPDATE 2019: how telling that you first have to agree to tracking cookies before reading the article…

Refusing to continue

Tue, 30 Jun 2009 15:52:08 +0200

I’ve seen this so many times, and thought about writing about it. Today I found some code that is too good an example to let it go. I’m talking about the refusal some people have to using the continue statement. Here is an example in some pseudo-code:

for value in list {
  if value.condition == True {
      do stuff
      do more stuff
  }
}

It looks like fine code, but personally I’d rather use:

for value in list {
  if value.condition == False: continue

  do stuff
  do more stuff
}

The philosophy behind my preferred way is to bail out as soon as possible. It makes your code easier to understand, because you know there is not going to be an else somewhere down the line. If you see continue you can mentally let go of that condition, because you know that the rest of the code in the loop will be skipped.

This simple principle of using continue as soon as possible to mentally free you of keeping track of conditions also applies to other flow control statements such as break and return. Here is something I see all too often:

function(object *values) {
   if(values != null) {
       do something with the values;
   } else {
       handle errors;
   }
}

Again, very simple code, nothing really wrong with it. Until “doing something with the values” involves checking for more errors and doing a loop. Things get nested very deeply very rapidly. Instead I propose to do it like this:

function(object *values) {
   if(values == null) {
       handle errors;
       return;
   }

   do something with the values;
}

When you have code like this, it is very easy to add more conditions and error checks without the main body of the code getting any more indents. The level of indentation is directly proportional to the mental effort required to understand the code. Being able to add conditions and checks without the code becoming more complex is a very good thing.

These were all very simple examples. I have been able to remove several bugs just by applying the bail out as soon as possible strategy to actually professionally written production code.

A function should have one return point

I have heard many times that people were taught that “A function should have one return point”. It sounds like a silly thing to me - why would you not return, when you already know the work that had to be done is done? Until now people were only able to explain my “Why?” question with “it was taught to me that way”. Of course learning something only to teach it again is very nice for folklore but not for programming styles.

In many modern languages (well, more like non-ancient languages) there are many more return points to a function than just the return statement: exceptions. Any function call can cause an exception, and if you don’t handle it that means that every call can be a potential point of return.

And now here’s a bit of code that triggered me to finally write this down:

while((item = map_rect_get_item(mr))) {
    first=1;
    while (item_coord_get(item, &c, 1)) {
        if (first)
            first=0;
        else {
            heightline=heightlines;
            rbbox.lu=last;
            rbbox.rl=last;
            coord_rect_extend(&rbbox, &c);
            while (heightline) {
                if (coord_rect_overlap(&rbbox, &heightline->bbox)) {
                    for (i = 0 ; i < heightline->count - 1; i++) {
                        if (heightline->c[i].x != heightline->c[i+1].x || heightline->c[i].y != heightline->c[i+1].y) {
                            if (line_intersection(heightline->c+i, heightline->c+i+1, &last, &c, &res)) {
                                diagram_point=g_new(struct diagram_point, 1);
                                diagram_point->c.x=dist+transform_distance(projection_mg, &last, &res);
                                diagram_point->c.y=heightline->height;
                                diagram_point->next=diagram_points;
                                diagram_points=diagram_point;
                                dbg(0,"%d %d\n", diagram_point->c.x, diagram_point->c.y);
                            }
                        }
                    }
                }
                heightline=heightline->next;
            }
            dist+=transform_distance(projection_mg, &last, &c);
        }
        last=c;
    }

}

With a few modifications I changed the code into this:

while((item = map_rect_get_item(mr))) {
    first=1;
    for(; item_coord_get(item, &c, 1); last=c) {
        if (first) {
            first=0;
            continue;
        }

        heightline=heightlines;
        rbbox.lu=last;
        rbbox.rl=last;
        coord_rect_extend(&rbbox, &c);
        for (; heightline; heightline=heightline->next) {
            if (!coord_rect_overlap(&rbbox, &heightline->bbox))
                continue

            for (i = 0 ; i < heightline->count - 1; i++) {
                if (heightline->c[i].x == heightline->c[i+1].x && heightline->c[i].y == heightline->c[i+1].y)
                    continue;

                if (!line_intersection(heightline->c+i, heightline->c+i+1, &last, &c, &res))
                    continue;

                diagram_point=g_new(struct diagram_point, 1);
                diagram_point->c.x=dist+transform_distance(projection_mg, &last, &res);
                diagram_point->c.y=heightline->height;
                diagram_point->next=diagram_points;
                diagram_points=diagram_point;
                dbg(0,"%d %d\n", diagram_point->c.x, diagram_point->c.y);
            }
        }
        dist+=transform_distance(projection_mg, &last, &c);
    }

}

Granted, it is still a big beast and should be split up into a few small functions, but still I was able to reduce the nesting level of the main piece of the code (the diagram_point lines) by four levels.

NOTE: The C code above was taken from Navit, an Open Source navigation application. Big kudos to the team that wrote the application, as it works well. By writing this article I do not want to imply anything about the quality of the Navit application in general, just about the small bit of code I copied.

Bl3nder CD presentation

Sun, 24 May 2009 21:38:20 +0200

Bl3nder | CD-presentatie Leipe Shit Ouwe!

I was hired to cover the presentation of Bl3nder’s first album “Leipe Shit Ouwe!”. Their performance was energetic and powerful, and I think it shows in the photos.

Slideshow

Multiblend 1.4 released

Wed, 08 Apr 2009 14:29:48 +0200

I’ve released a new version of Multiblend! Version 1.4 has the following improvements over the previous version:

Display timing info after rendering.
Added -E option to skip existing frames and render only the missing ones.
Smarter distribution of frames.
Implemented simpler logging.
Verifies that the output directory exists before rendering.
Added ‘cachesync’ executable that can distribute the Blender cache directory (such as used with particle systems) to nodes.
Removed use of the md5 module when using Python 2.6 or newer.
Replaced the popen2 module with the subprocess module. This limits the compatibility of Multiblend to Python 2.4 or newer on the master node.
Split the implementation into several modules to increase maintainability and insulation of the parts.

Multiblend connects to multiple computers on your network, and lets Blender render in parallel on each. This will drastically improve your rendering speeds!

Fighting for Umlaut

Wed, 08 Apr 2009 11:12:40 +0200

For my Master of Science course in Game & Media Technology at the Utrecht University I had to make another 3D animation. This time the focus was on more traditional animation techniques such as stretch-and-squash.

The assignment was to make a 3D animation with your last name playing a role. I chose this particular subject as many, many computer programmers are having a hard time separating UTF-8 from Latin-1, which renders my last name as StÃ¼vel :(

Cleaning up an Ubuntu system

Tue, 31 Mar 2009 19:12:41 +0200

Ubuntu uses quite a nifty package manager. It keeps track of which file belongs to which package. Not only that - it also keeps track of which packages you requested, and which were installed as a dependency.

The package manager can remove unused dependencies automatically. And this is what we’ll be using to clean up your Ubuntu system. You see, you can mark packages as installed automatically, even if at some point you requested them yourself. By marking them as “automatically installed” you can be sure that they are only removed when they really aren’t needed any more. Here’s how it’s done:

make a list of manually installed packages:

aptitude search '~i!~E' -F '%M %100p' | grep -v ^A > manual_to_auto

edit the file and remove from the file the packages you want to keep.
read through the manual_to_auto file again to see whether you can afford to remove the packages that are in there.
mark all packages that you left in the file as “automatic”. This will show a list of packages that will be removed and give you a chance to review the changes and bail out before anything harmful happens. Feel free to abort, re-edit the manual_to_auto file and try again until you’re happy
```
sudo aptitude markauto $(< manual_to_auto)
```
Be happy with the free space. I’ve freed up 1 GB on one machine and 500 MB on another with this method.

I suggest you remove at least the following packages from the manual_to_auto file:

linux-generic
linux-image-generic
linux-restricted-modules-generic
ubuntu-standard
ubuntu-minimal
ubuntu-keyring
the ….-desktop packages

Be careful; if you’re in doubt, remove the package from the list. Everything that you remove from the file will be kept as “manually installed”.

If you find out that you removed too many packages, you can simply reinstall the ones you need. Since we haven’t purged the configuration files (see below) they should simply work as before when you reinstall them.

I’ve used information from various sources. However, most of them fail on long package names like linux-restricted-modules-2.6.24-23-generic, because by default Aptitude only shows the first 30 characters of the package name. I also feel more comfortable having a file that I can edit and review before actually marking any packages.

Another cleanup step can be performed by removing all configuration files that belong to uninstalled packages:

dpkg -l | grep ^r | awk '{ print $2 }' | sudo xargs dpkg --purge

Be warned: this command does not ask for any confirmation. Don’t come crying to me when it runs off with your girlfriend.

RSA version 1.3 released

Thu, 22 Jan 2009 15:12:42 +0100

A new version of my pure-Python RSA implementation has been released. The one major change is improved compatibility with Windows.

Download EGG files for Python 2.4, Python 2.5 or the source package at the Python Package index.

Toying with Voronoi diagrams

Mon, 12 Jan 2009 16:40:44 +0100

For my Master of Science degree I have to work with Voronoi diagrams. They can be easily visualized (and toyed with) with the DotPlacer applet.

Just enable the “Voronoi” check box, and add some points!

Bridged networking in KVM

Thu, 08 Jan 2009 08:56:13 +0100

One of the advantages of VMWare is that it has easy to set up bridged networking. However, I love Open Source so I started to experiment with KVM, the Kernel-based Virtual Machine.

Setting up bridging is a bit daunting, but not that complex once you’ve gotten the hang of it. I placed everything in a script for easy invocation. One of the features I wanted was that ending the script should tear down the bridged network, even when pressing Ctrl+C. This is my script:

#!/bin/bash -x

if [ "$USER" != 'root' ]; then
    echo "Restarting as root"
    exec sudo "$0" "$@"
fi

brctl addbr br0
brctl addif br0 eth0
ifconfig eth0 0.0.0.0 promisc up
ifconfig br0 172.27.0.2 netmask 255.255.255.0
route add default gw 172.27.0.1 br0

function restoreNet {
    ifconfig br0 down
    brctl delif br0 eth0
    brctl delbr br0

    ifconfig eth0 172.27.0.2 netmask 255.255.255.0
    route add default gw 172.27.0.1 eth0
}

trap restoreNet EXIT

kvm \
    -localtime \
    -hda kvm-xp.qcow \
    -m 512 \
    -usb -usbdevice tablet \
    -net nic \
    -net tap \
    "$@"

Some of the features are:

It starts bridging eth0 and the virtual machine’s network. This means that the VM can do a DHCP query and get an address from my DHCP server, for instance.
The bridge is always removed when the script ends.
The mouse simulates a tablet. This allows for absolute positioning, which you’ll notice allows your mouse to transparently move between your host system and the VM.
Any commandline arguments you give to the script are passed to KVM.
To create and remove the bridge, the script needs to run as root. If you didn’t run it as root, it automatically uses sudo.

Things you’ll probably want to edit:

My desktop uses a fixed IP address 172.27.0.2, replace that with your own IP address.
My gateway has IP address 172.27.0.1, replace that with your gateway/router address.
My desktop uses eth0 to connect to the network. If you use another device, replace it.
I use this setup to run Windows XP in KVM. The Windows installation is stored in kvm-xp.qcow, replace that with the harddisk image you want to use.

Enjoy! If you have any questions or remarks, post a comment below.

I can only get health insurance by breaking the law

Sun, 28 Dec 2008 14:55:06 +0100

I wrote an updated version of this blog post in 2016, and keep the list of f*ckups up to date there: My Name in the Modern World.

My last name is Stüvel. Apparently, this is very difficult for many programmers and testers to understand. Here are a few of the ways that my name is displayed by various applications:

St??vel
St�vel
St++vel
StÃ¼vel
Stüvel
… for more, see the link above. I keep that one up to date. The story below is still relevant though, and I didn’t repeat that in the 2016 post:

Nowadays it gets so bad that I’m having trouble applying for health insurance! When applying, I have to fill in my name and other personal information on the insurer’s website. There is much money (and fraud) involved in health insurance, so they stress that you are obliged by law to correctly fill in your personal information. This is something I cannot do. When I give them “Stüvel”, they ask me to confirm that my name is “Stüvel”, which I cannot do by law. Then again, I am not allowed to give any other name than my real name, so “Stuvel” is out of the question - it is forbidden by law. In other words: I can only get health insurance by breaking the law.

Pretty please with sugar on top, accept that we live in a world that is made up of more than A-Z and design your systems for it. Unicode has been a published standard since 1991. Perhaps it’s a good idea to start using it.

Resting in NWN2: Storm of Zehir

Fri, 19 Dec 2008 14:55:23 +0100

The new Neverwinter Nights 2 expansion Storm of Zehir disallows resting in many areas. This is much more restrictive than what we’re familiar with in other NWN2 campaigns - or any other D&D-based game, for that matter. Even after you clean out an entire dungeon, you’re still not allowed to rest there.

The solution they give is the Stone of Alarm. It sounds an alarm when enemies get near, allowing you to shut your eyes and get some well deserved rest. Unfortunately, the stone works only once, and costs around 1000 gold pieces. I thought this to be rather lame - to have to pay 1000 gold for each rest is expensive, especially since we’re used to always being able to rest.

My solution: unzip my altered Stone of Many Alarms ZIP file in your NWN2/Override directory, and buy a new Stone of Alarm or give it to yourself:

press ~
type “DebugMode 1”, enter
type “giveitem nx2_t_alarmstone 1”, enter
type “DebugMode 0”, enter
press ~

Enjoy resting like we’re used to!

PS: the alarm stone fix by “player1” is also part of this new Stone of Many Alarms. Thanks player1!

Download the Stone of Many Alarms

The Soundabout performing in Buk Buk

Fri, 12 Dec 2008 14:45:36 +0100

I’ll be performing as the drummer of my band The Soundabout in BukBuk, Heiloo, this evening. We’re a ska/funk/reggae band, and play as support act for De Skatjes.

Buk Buk is easy to reach by train, only a two minute walk from the train station. The doors open at 21h, we play at 22h and De Skatjes start at 23h. Damage: €5,-

Python Flickr API 1.2 released

Sat, 15 Nov 2008 18:17:08 +0100

Today I released the Python Flickr API version 1.2. Originally the Python interface was made by Beej, and since it’s seen many an improvement. Here’s what’s new in this version:

Added ElementTree support for Python 2.4.
Made ElementTree the default response parser.
The upload and replace methods now take a format parameter.
Removed deprecated methods.
Upload and replace methods no longer report progress on their callback regarding the HTTP headers.

Hacking in Fallout 3, even easier

Sat, 08 Nov 2008 22:41:11 +0100

Hacking in Fallout 3 has become easier than ever. Now all you need is this website and some typing and clicking. No more cracking your brains, no more hard and difficult counting and checking letters, it’s all done for you!

Hacking in Fallout 3

Thu, 06 Nov 2008 20:26:57 +0100

Fallout 3 is my latest addiction. It’s a great game by the makers of Oblivion. Part of the game is the hacking of computer terminals. It is basically a Master Mind game, but then with letters. You click on a word that shows up in a memory dump of the terminal you are trying to hack, and the terminal tells you how many letters are correct and in the correct place. Of course, a real hacker would write a program to solve the puzzle. So, here it is:

#!/usr/bin/env python

known = {
    'detector': 1,
}

words = '''
detector carpeted declared detailed dramatic devoured demanded
sinister disposal revealed messages released remained defended
peaceful designed prisoner
'''

words = set(words.split())

def dist(a, b):
    return sum(la == lb for (la, lb) in zip(a, b))

for k in known:
    for w in set(words):
        if dist(k, w) != known[k]:
            words.discard(w)
print "Try any of:", ', '.join(words)

The variable words should be filled with all the words you see on the terminal screen. The known variable should contain a dictionary with the known information you got from the terminal. For example, if you pick those:

detector: 1/8 correct
demanded: 2/8 correct

then the known variable should be:

known = {
    'detector': 1,
    'demanded': 2,
}

If you then run the program (using python fallout.py if you saved the script as fallout.py) it will tell you to try “carpeted” or “messages” as your next guess.

The script requires Python, which is installed by default on most Linux and MacOS systems and should be manually installed on Windows.

update: I have automated the hacking so you can easily use this website to make the sometimes difficult hacking a lot easier.

Java does not support Unicode, Python does

Mon, 03 Nov 2008 03:41:55 +0100

Sometimes Java just amazes me. As a friend of mine posted, Java does not support Unicode. Of course, my favourite language Python has a much friendlier approach to Unicode:

>>> s = '⿱𠂉乙'.decode('utf-8')
>>> s
u'\u2ff1\U00020089\u4e59'
>>> s[1]
u'\U00020089'
>>> print s[1]
𠂉

Perhaps,. people will some day start to understand that statically typed languages are not a guarantee of a bug-free application. In the end, it’s more important that a language does what it is supposed to do.

Pong

Wed, 29 Oct 2008 06:10:40 +0100

For the Utrecht University I made a short animation called Pong. together with two fellow students. We used Blender to add models to the MoCap data we recorded, and rendered with Blender + Multiblend.

Bl3nder at Uitmarkt

Sat, 30 Aug 2008 21:52:33 +0200

Bl3nder | Cyril Directie

De Uitmarkt is the opening of the cultural season in Amsterdam. We went to see Bl3nder, and they totally rocked! It was the first time I saw Def P (the world’s best rapper) live, and it was everything I hoped for :) Their drummer was absolutely amazing!

Of course, I’ve taken a few shots

Pure-Python RSA module version 1.2 released under EUPL

Fri, 06 Jun 2008 14:20:51 +0200

By popular demand, we’ve re-licensed our pure-Python RSA module under the European Union Public Licence ( EUPL). This new licence is the first open source license to be released by an international governing body.

RSA version 1.2 is code-wise the same as the previous version - the only difference is the new license. It is also still compatible the GPL. Actually, the module is now dual-licensed, under both the GPL and the EUPL. Take your pick, and use which one suits you best.

Selecting NVidia screens on commandline

Sat, 24 May 2008 19:33:35 +0200

NVidia has a nice program to manage display devices like monitors, TVs etc. I’ve used this often to play movies on my PC and watch them on our big wide screen LCD TV. What I wanted to do, is automate switching between monitor and TV. The final goal is that I can push a button on a remote to switch the output. Hey, I’m a software engineer, I automate things.

The easiest way to do that would be two write a shell script that can perform the switch for me. NVidia has be so kind as to provide us with software that can do that. It’s nv-control-dpy, packaged in the nvidia-settings source, combined with xrandr.

Here is a step-by-step guide of how I managed to get things running.

Hook up your TV if you haven’t done so.

Let X detect the TV:

nv-control-dpy --probe-dpys
nv-control-dpy --build-modepool

Tell X to include the TV in the current set of displays. You do this by getting a list of numbers from nv-control-dpy --get-associated-dpys:

Using NV-CONTROL extension 1.14 on :0
Connected Display Devices:
  CRT-0 (0x00000001): Acer AL1906
  CRT-1 (0x00000002): SAMSUNG

associated display device mask: 0x00000001

Add the two (0x...) numbers together and include them in the next call:

nv-control-dpy --set-associated-dpys 0x00000003

Add a metamode so that X knows which device to enable/disable. The above command gave you the names and numbers of the display devices - they could be TV-0, CRT-1, DPY-4, etc. To enable the device, set it to “nvidia-auto-select”. To disable a device, set it to “NULL”. Here is the command that I gave to disable my Acer monitor and enable my Samsung TV:
```
nv-control-dpy --add-metamode \
    'CRT-0: NULL, CRT-1: nvidia-auto-select'
```

The last step is to tell X to actually perform the switch. You use the xrandr command for this. First, get a list of possible resolutions using xrandr:

Screen 0: minimum 320 x 240, current 1280 x 1024
default connected 1280x1024+0+0 0mm x 0mm
   1280x1024      50.0*    51.0
   1280x960       52.0
   1280x800       53.0
   1280x768       54.0
   1152x864       55.0     56.0
   1152x768       57.0
   1024x768       58.0     59.0     60.0
   832x624        61.0
   800x600        62.0     63.0     64.0     65.0
   800x512        66.0
   720x450        67.0
   700x525        68.0     69.0
   640x480        70.0     71.0     72.0
   576x384        73.0
   512x384        74.0     75.0
   400x300        76.0
   320x240        77.0     78.0
   1360x768       79.0

The last resolution in that list is the metamode we just added. To switch to it, use xrandr -s resolution@refreshrate:
```
xrandr -s 1360x768@79
```

To switch back, use the same xrandr -s resolution@refreshrate trick, in my case xrandr -s 1280x1024@50

Once you’ve figured out the names of the devices, the bit masks and the meta mode lines, you can of course place the commands in shell scripts and really get to automate stuff. I’ll leave that as an exercise for the reader.

RSA version 1.1 released

Wed, 23 Apr 2008 11:42:02 +0200

A pure Python implementation of the RSA cryptographic protocol. It contains functions for encryption, decryption, signing, verification, and the generation of keys and prime numbers.

The recursive nature of RSA version 1.0 prevented the use of large keys. Thanks to Miguel Angel Vilela of the Google Enterprise Support Team version 1.1 handles large keys just fine.

The RSA module page contains the download links and examples.

More info on the use of RSA in Google Apps on App Engine Fan’s AppEngine and Encryption blog entry.

Python vs. Java

Thu, 10 Apr 2008 09:27:13 +0200

One of the major reasons my company prefers Java over Python, is Java’s static type declarations (and all the benefits that follow). If only Python had that, my life would be so much nicer. Here is an example of code I have to work with, and an example of what the Python equivalent would look like.

The background of the code: We have a list of “identifiers” that can identify people who want to use a parking garage. These can be NFC cards, credit cards, and bar codes. We want to filter the list of known identifiers and return only those of type “barcode”.

The code in Java:

private List<Identifier> barcodeTypeOnly(List<Identifier> ids)
{
    final List<Identifier> barcodes = new ArrayList<Identifier>();

    for (Identifier id : ids) {
        if (id.getType().equals(Identifier.TYPEBARCODE)) {
            barcodes.add(id);
        }
    }

    return barcodes;
}

What it would look like in Python:

ids = the list of identifiers

barcodes = [identifier for identifier in ids
            if identifier.type == Identifier.TYPEBARCODE]</pre>

You could write that last one on a single line, but for clarity I wrote it like this. I understand that the list comprehension construction may not be instantly recognisable, so I wrote a little explanation after the break.

A primer on list comprehensions

The idea behind list comprehensions is that an iterable (like a list) goes in, and a list comes out. In its simplest form:

result = [someobject for someobject in somelist]

This would give you a shallow copy of the list, so it’s a silly example. Here is a more useful one - let’s say all your objects have a name, and you want to create a list of names:

names = [someobject.name for someobject in somelist]

In Java it would be coded like this:

private List<String> getNames(List<NamedObject> objects) {
    List<String> names = new ArrayList<String>(objects.size());

    foreach(NamedObject object : objects) {
        names.add(object.name);
    }

    return names;
}

Adding a filter

Let’s say you don’t want a list of all object names, but those names where someobject.type == 'car'. That’s where the if clause comes in:

names = [vehicle.name
         for vehicle in somelist
         if vehicle.type == 'car']

Filtering can be very useful; I’ve used this in a testing environment, where commands are executed and can fail or succeed. Getting a list of all failed commands is as easy as:

failed = [command for command in executed
          if command.status != command.SUCCESS]

Other similar constructions

You can create a “generator expression” by using the same syntax, but removing the blocky brackets. This allows you to efficiently use the any() or all() functions, for example:

success = all(command.status == command.SUCCESS for command in executed)

This will stop iterating the executed list as soon as a single failed command was found.

Recent versions of Python (3.1, 2.7) have other, very similar constructions. With the same ease you can create and filter sets and dictionaries.

Local transparent HTTP proxy with Squid

Fri, 15 Feb 2008 10:53:15 +0100

Setting up Squid as a transparent HTTP proxy has been discussed plenty of times. All of these examples and blogs I’ve read on the subject assume that you run Squid on your network gateway. While this is a very common and sensible set up, it doesn’t suit my need. I need to lock down one single computer and perform filtering using Squid’s ACL mechanism, regardless of the network it’s plugged into.

I’ve written an article called Local transparent HTTP proxy on this subject. It handles IPTables and Squid configuration, and highlights the special needs that arise when running a mandatory transparent HTTP proxy on a client machine.

ValueError & Mercurial

Tue, 05 Feb 2008 22:30:03 +0100

I’ve been playing with Mercurial’s hooks lately. After I updated to the latest version (0.9.5) and toying a bit more with the hooks, I got this error after a hg push:

ValueError: invalid literal for int() with base 10: ‘1 files updated, 0 files merged, 0 files removed, 0 files unresolvedn’

The cause was my hook, which produced output that Mercurial didn’t expect. The solution was to redirect the output to a log file. My hook config went from:

[hooks]
changegroup = hg update && ./localize && ./restart

to:

[hooks]
changegroup = (hg update && ./localize && ./restart) > push.log

This is the hook that’s used on my webserver. All I need to do is a hg push command on my development machine, and my latest changes are pushed to my webserver, which in turn updates the website files and restarts the server to load in the new script.

New look

Sun, 03 Feb 2008 15:29:30 +0100

I’ve updated the look of this site. Unfortunately for Microsoft Internet Explorer users, I couldn’t get the new look to work in that browser. Its CSS support is just too limited. Sorry for the die-hard MSIE users. Perhaps it’s time to upgrade to Firefox?

PVR support in MPlayer

Fri, 28 Dec 2007 00:25:42 +0100

When toying around with mplayer and my Hauppauge PVR350, I got the following error when trying to play something:

[pvr] failed with errno 22 when reading 2048 bytes
[pvr] read 0 bytes

The error kept repeating. The solution was to give the proper bitrates. I used the following for DVD-compatible rates in my ~/.mplayer/config file:

[ivtv]
mpegopts=format=dvd
tv=normid=0:device=/dev/video0:width=720:height=576
pvr=arate=48000:abitrate=384:vbitrate=6000000:
         vpeak=9600000:aspect=1:fmt=dvd
of=mpeg=1

To play, use mplayer pvr:// -profile ivtv. You can also copy this section to your mencoder config file and store the video stream from your PVR card to a dvd-compatible MPEG2 stream. I’ve successfully burnt such a file using KMediaFactory and K3B.

Tilt wheel & Logitech mx610

Sat, 03 Nov 2007 18:07:55 +0100

I’ve got a Logitech MX610 cordless laser mouse. One of its nicer features is a tilt wheel. Unfortunately, this is still difficult to get working in Ubuntu Linux. The problems:

The tilt wheel is only supported when you’re using the “evdev” driver. Ubuntu doesn’t do this by default.
Xorg refuses to load an event device if it isn’t named /dev/input/eventX where X is a single digit.
The MX610 contains an USB keyboard as well, which is used for certain buttons. The mouse and the keyboard components have the same name, so the standard tutorials for getting the tilt wheel working don’t work.

After a bit of twiddling, I got everything to work. Edit your /etc/X11/xorg.conf file and replace your mouse definition with this:

Section "InputDevice"
   Identifier  "Configured Mouse"
   Driver      "evdev"
   Option      "CorePointer"
   Option      "Device"    "/dev/input/event9"
   Option      "ZAxisMapping" "4 5 7 6"
   Option      "Buttons"   "9"
   Option      "Resolution" "800"
EndSection

Place the following in /etc/udev/rules.d/66-logitech_mouse.rules:

KERNEL!="event*", GOTO="logimouse_rules_end"
ENV{ID_CLASS}!="mouse", GOTO="logimouse_rules_end"
ENV{ID_MODEL}!="USB_Receiver", GOTO="logimouse_rules_end"
ENV{ID_VENDOR}!="Logitech", GOTO="logimouse_rules_end"

ACTION=="remove", RUN+="/bin/rm /dev/input/event9"

ACTION!="add", GOTO="logimouse_rules_end"
RUN+="/bin/bash -c '/bin/mknod /dev/input/event9 c ${MAJOR} ${MINOR}"

LABEL="logimouse_rules_end"

Reboot, and enjoy your tilt wheel!

More power from your mobile's battery

Tue, 09 Oct 2007 13:36:35 +0200

I’m the happy owner of a Motorola Razr V3. Its battery used to last quite long, but now that it’s getting older it’s drained very quickly. At some point, I could charge it at night, talk a few minutes during the day, and when I got home in the evening the battery would be empty.

Fortunately, I found a solution for this! The phone “thinks” that the battery is full way too early, stopping the charging process. To get a full battery that lasts for days, just turn off your mobile while charging it. This will fill it up all the way.

Uitmarkt 2007

Sat, 25 Aug 2007 14:04:03 +0200

There was a spectacular opening of the Uitmarkt in Amsterdam. Of all the photos I shot that evening, I’ve uploaded the best 11. Take a look at Uitmarkt 2007 - a photoset on Flickr.

Proper Exception handling

Mon, 13 Aug 2007 11:10:33 +0200

UPDATE 2019: The articles below have been taken offline.

The articles below are about Java, but I think they apply equally well to other languages that have exception handling. It would be nice if more were to read those articles. I think it would result in better and easier to debug code.

Highlighting the current line & column in VIM

Fri, 20 Jul 2007 10:35:16 +0200

It’s already in the VIM help file, but I never found it until now. To highlight the current row/line and the current column use this in your .vimrc:

au WinLeave * set nocursorline nocursorcolumn
au WinEnter * set cursorline cursorcolumn
set cursorline cursorcolumn

I found this quite useful while programming. Eclipse has a similar feature; when I got used to that I started missing it in VIM. Until now that is :)

Encoding video for the iriver U10

Wed, 20 Jun 2007 21:45:04 +0200

I own an iriver U10. It’s a great device, that can play music and video. However, for some reason, none of the tutorials about encoding video for the iriver U10 worked. When I try to play the video, it just gives the message “This file format is not supported”. After a lot of trial and error I finally figured out the problem: the frame rate. According to every guide and manual I found, the U10 can handle 15 frames per second. However, things only started working when I encoded to 14.9 frames per second!

Here is the mencoder command I used:

/usr/bin/mencoder \
  flash_gordon.avi \
  -o flash_gordon-u10.avi \
  -ovc xvid -xvidencopts bitrate=384:max_bframes=0 \
  -oac mp3lame \
  -lameopts mode=0:cbr:br=128 \
  -ofps 14.9 \
  -af resample=44100:1:2 \
  -vf-add scale=320:240,expand=320:240 \
  -vf-add harddup \
  -quiet

I’m sure other encoders (GUI or otherwise) will also work, as long as you use the following settings:

14.9 frames per second (FPS)
AVI output format
XviD video codec at 384 kbit/sec
No B-frames (just enter 0 for the number of B-frames)
Video 320x240 pixels
MP3 audio codec at 128 kbit/sec, 16 bit, stereo

I’ve verified these settings with Avidemux. And yes, they also work with clips from Youtube!

Safely copy a SQLite database

Fri, 15 Jun 2007 08:58:17 +0200

It’s trivially easy to copy a SQLite database. It’s less trivial to do this in a way that won’t corrupt it. Here’s how:

$ sqlite3 some.db
sqlite> begin immediate;
<press CTRL+Z>
$ cp some.db some.db.backup
$ exit
sqlite> rollback;

This will give you a nice clean backup that’s sure to be in a proper state, since writing to the database half-way through your copying process is impossible.

Thanks to Habbie for this info!

Stuvel.eu moved to a better server

Tue, 12 Jun 2007 23:59:30 +0200

The Stuvel.eu website has moved from a 1 Mbit ADSL connection to a real server on a proper 100 Mbit link. If you read this message, the DNS entries have been updated and you’re looking at the new server. I’m sure you’ll notice the speed improvement ;-)

Better RAW decoding with Digikam

Thu, 07 Jun 2007 20:42:43 +0200

My favourite photo editor and manager is Digikam. One of its features is easily importing RAW files. However, with its default settings you may loose details in brightly lit areas of your photos.

To get the details back, go to Settings, Configure digikam, RAW decoding. In there, set the “Highlights” option to “Reconstruct”. Now that you’re there anyway, set “Quality” to “AHD interpolation”, which is the highest quality of interpolation.

With these settings, you’ll get much higher quality images. They may turn out dark if the highlight is much brighter than the rest of the image. However, this is easily reconstructed with the white balance tool (CTRL+W) and playing with the exposure and gamma settings.

Flickr lens:type machine tag

Mon, 04 Jun 2007 19:26:39 +0200

I’m in the process of giving all my photos a “lens:type” machine tag on Flickr. This will indicate which lens I used to make the photo. Check it out:

It’s all done automagically by a Python script I wrote. It analyses things like the date at which the photo was taken, focal length and aperture size to determine which lens I used. It’s a very boring and repetitive task and I’m glad I could delegate it to a computer.

If you’re interested in the script let me know and I’ll send you a copy. Since the analysing logic of the program will need adjustment to your set of lenses, it requires at least some Python knowledge. This is also the reason why I didn’t put the program online - in its current form it’s not useful for anyone else.

The script uses the Flickr API to interface with Flickr.

Double-sided macro tent

Thu, 31 May 2007 19:14:49 +0200

UPDATE 2019: With Flickr limiting the number of photos you can upload with a free account, I’ve removed these photos.

I’ve written a small tutorial about how I set up my double-sided macro tent.

The idea was born out of sheer lack of money. As I spent all of it on glass, I have to work with just one construction lamp and my built-in flash.

To get the maximum amount of light out of my limited means, I thought up a nifty macro tent to suit my needs.

Calculating with OpenOffice.org

Fri, 11 May 2007 12:33:46 +0200

Joachim Dahl asked me to give an example of using OpenOffice.org spreadsheet formulas from Python. After a bit of digging I found out that it’s rather easy. I’ve added a section to my “OpenOffice.org & Python” document called Calculating with OpenOffce.org which gives a simple example of how it’s done.

Bordering an image

Wed, 09 May 2007 08:25:45 +0200

Pictures look better when they have a border around them. To make things easy for me, I’ve written a small script that does a lot of boring things for me. It resizes an image so that it fits a 1000x1000 square, then creates a black border around it that’s a slight bit larger at the bottom and places my name and website URL on the side. Here is the code:

#!/bin/bash

[ -z "$1" ] && echo "Usage: $0 <file>" && exit 1

IN="$1"
IN_NOEXT=$(echo $IN | sed 's/\\.[^.]\\+$//')
OUT="$IN_NOEXT-bordered.jpg"
echo "INPUT: $IN"
echo "OUTPUT: $OUT"

BORDER_BOTTOM=40
BORDER_OTHER=20
POINTSIZE=12
COPYRIGHT="© 2007 Sybren Stüvel - https://www.stuvel.eu/"

DIFF=$((BORDER_BOTTOM - BORDER_OTHER))
EXIFTOOL=/usr/bin/exiftool

convert "$IN" \
 -geometry 1000x1000 \
 -mattecolor black \
 -frame ${BORDER_BOTTOM}x${BORDER_BOTTOM} \
 -chop ${DIFF}x${DIFF} \
 -gravity SouthEast \
 -chop ${DIFF}x0 \
 -font Bookman-Light \
 -font Helvetica-Narrow \
 -font Helvetica\
 -pointsize $POINTSIZE \
 -gravity SouthWest \
 -fill gray20 \
 -annotate 270x270+$((POINTSIZE+2))+${BORDER_BOTTOM} \
 "$COPYRIGHT" \
 "$OUT"

$EXIFTOOL -TagsFromFile "$IN" "$OUT"
rm -f "${OUT}_original"

Back from holiday

Sat, 05 May 2007 14:00:40 +0200

UPDATE 2019: The photos are no longer online.

I’m back from holiday. We went hitchhiking from Amsterdam to Muker in the Yorkshire Dales (UK). Of course, there are plenty of pictures.

We went on a contest - 27 couples were racing to get from Amsterdam to Muker without paying for their transportation. The only thing we were allowed to pay was the ferry from Calais to Dover. We started at 17:00 hours (local time) in Amsterdam, and arrived in Muker at 23:45 (also local time). It was a wonderful trip!

A shorter self-timer on a Canon EOS 350D

Sat, 14 Apr 2007 17:47:50 +0200

The Canon EOS 350D has a fixed self-timer of 10 seconds, and the manual doesn’t mention any way of shortening it. I use the self-timer for night shots, where even the movement of a button press can mess up an otherwise perfect photo. For such usage, those 10 seconds are quite long.

I started to play with the “mirror lock-up” feature. In the custom functions (C.Fn.) menu you can enable mirror lock-up. If you do this and then use the self-timer, the timer is reduced to about a second. This means a double advantage of the mirror lock-up feature: less movement blur and also less waiting.

Update

I got some questions about the workings of the mirror lock-up. When you use the self-timer, taking a photo follows those steps:

Focus the camera either manually or with the auto-focus.
Fully press the shutter button.
The mirror now locks into the upper position and the self-timer starts to run.
About a second or two later the photo is taken.
The mirror comes back down again so you can prepare for another shot.

Which unit do you shoot first?

Wed, 11 Apr 2007 18:03:46 +0200

In every Real Time Strategy game, there comes a time that you face your enemy in combat. Then you have to decide which unit to attack first. There are many ideas about optimal strategies, and many of them have good arguments. I decided to write a small simulator to find the optimal strategy.

I implemented strategies based on the number of hit points and the firepower of enemy units. Every simulation round all the enemy units fire at me, and I fire at a single enemy unit. The best strategy? Find the unit with the most firepower per hit point and whack it. However, this does requires quite some math, since the hit points change and thus the firepower / hit point ratio changes about every second.

Unless you can do a lot of math in a very short time, easier to fire at the unit with the most firepower. Almost just as good is shooting at the unit with the least hit points. Which one of those two is best probably depends on the game and the units you’re facing.

Focusing your firepower on the unit with the least fire power or the unit with the most hit points is really bad. It’s better to just pick a unit at random.

Here are the actual results. The number is the total damage the enemy units did to the simulated “me”, hence lower is better.

findMostFPperHP    2934277
findMostFP         3546364
findLeastHP        3603899
findRandom         6908600
findLeastFP        7470776
findLeastFPperHP  10460769
findMostHP        10482618

Single-click buttons for webapps

Wed, 04 Apr 2007 11:08:33 +0200

UPDATE 2019: the below article is long gone.

Many web applications can’t handle it when links and buttons are clicked while a page request is already being processed. To prevent your application from those trigger-happy mouse clicking users, read my article about single-click buttons.

Line numbers in VIM's search & replace

Mon, 26 Mar 2007 14:30:58 +0200

Often, I have to assign a list of Selenium parameters $p1 through $pN to a list of more meaningful names. With VIM, this is easily done. First, place the meaningful names in the editor, one name per line:

name
street
housenumber
city

Then type the command :%s/.*/#set $& = $pXXX and hit enter. This is the result:

#set $name = $pXXX
#set $street = $pXXX
#set $housenumber = $pXXX
#set $city = $pXXX`

Now all that’s left is to change the XXX to the appropriate number. Type :%s/XXX/\=line(".") and hit enter to get this:

#set $name = $p1
#set $street = $p2
#set $housenumber = $p3
#set $city = $p4

Of course, this is all rather trivial. However, with longer list and slightly more complex regular expressions, this is a very powerful technique. Think about 30 files with 20 #set commands per file, and you have to insert one more at the top and rename the rest. With VIM, that’s a piece of cake.

By the way - both commands could have been combined into one. However, that would make the commands more complex and hard to understand. For the curious, the command is :%s/.*/\="#set $" . submatch(0) . " = $p" . line(".")

Photography

Fri, 16 Mar 2007 23:49:20 +0100

UPDATE 2019: The described page about photography is gone from my website, as well as the Flickr RSS feed link. I still am a photographer, though, so check out stuvelfoto.nl for my work.

I’ve been photographing quite a lot lately. and I thought it would be time to devote some web space to it. Voila, a small page about photography. You’ll also notice a link to the RSS photo feed from Flickr.

Blame support in Eclipse

Thu, 15 Mar 2007 10:19:44 +0100

Eclipse has support for CVS annotations, also known as “blame support”. Right-click on a file, choose “Team”, “Show annotation” and you’ll see who last edited which line of code.

However, if you ever turn off quick diff, this feature will stop working. The solution: press Ctrl+Shift+Q to enable quick diff before you choose “Show annotation”.

More Supreme Commander cheats

Thu, 15 Feb 2007 20:32:56 +0100

This is an extention of the cheat I published earlier.

Before you can copy & paste units and buildings, you have to be able to select them. You might have noticed that you can’t select everything - not enemy units nor unfinished units/buildings.

Here is a really powerful trick: press the tilde/backtick button [~] to open the console, type “ui_selectanything”, press enter then press the tilde/backtick button again to close the console. Now you can select anything!

Try this:

Start building a building
Immediately copy & paste
Now you have a finished building!

This also works for experimental units! Start building a Monkeylord, copy & paste it, and now you have a fully finished Monkeylord within seconds.

Winter Juggling Weekend

Sun, 04 Feb 2007 21:21:26 +0100

UPDATE 2019: With Flickr limiting the number of photos you can upload with a free account, I’ve removed these photos.

This weekend I went to the Winter Juggling Weekend in Heerlen, The Netherlands. It was the first time I went to such an event, and it was really nice. I also managed to free-mount a 36" unicycle, and I’ve made up my mind - I’ll buy one in a few months when the whether gets better. In the mean time, enjoy the photos I made on Flickr.

Supreme Commander cheat

Wed, 24 Jan 2007 17:33:49 +0100

After some fiddling with Supreme Commander, I found out how to cheat in a skirmish game. Of course, you first have to start the game with “Cheats: on”. You can then copy & paste units. Select a unit, press [Ctrl] + [Shift] + [C] to copy it. Now press [Ctrl] + [Shift] + [V] to paste it. Lather, rinse, repeat.

With this, you can create mutliple commanders to build super fast. You can also build a single unit, then copy it multiple times to create an army. The pasted units appear below the mouse cursor, so be creative with their placement. Be careful, though. The game can crash if you paste too many units at the same location.

Also note that this method isn’t restricted to copying single units - you can select an entire group and copy that. This means every copy & paste action can double your strength!

By the way, I seem to be the first one to publish a cheat for this marvellous game!

Also be sure to read my news post More Supreme Commander cheats.

Plucker-build and Ubuntu

Sun, 21 Jan 2007 15:37:19 +0100

Plucker is a PDB (Palm e-book documents) reader and creator. I use it to convert HTML files to PDB format, so that I can comfortly read them on my PDA. Plucker is part of Ubuntu’s “universe” repository, but it installs rather crippled. Do this to fix it:

sudo su - (type your password to become root)
cd /usr/bin
PYPLUCKER=../lib/python2.4/site-packages/PyPlucker
ln -fs $PYPLUCKER/Spider.py plucker-build
ln -fs $PYPLUCKER/PluckerDocs.py plucker-de
ln -fs $PYPLUCKER/PluckerDocs.py plucker-decode
ln -fs $PYPLUCKER/Decode.py plucker-dump
ln -fs $PYPLUCKER/pluck-comics.py pluck-comics

After doing this, you’ll be able to do:

plucker-build somefile.html > somefile.pdb

to create the files.

BUG: soft lockup detected on CPU#0

Tue, 26 Dec 2006 20:51:28 +0100

I just got me a brand new HP Pavillion DV9000 series laptop. Today, all of a sudden it refused to boot. This message was shown on the console while booting:

BUG: soft lockup detected on CPU#0

After some Googling people mentioned this message after inserting a WiFi card. I did just the opposite, though. The message started to appear when I booted with my WiFi card disabled by means of the kill switch at the front. Re-enabling the WiFi card was the solution. If my WiFi is turned on when I boot, my laptop boots just fine!

Graduation thesis online

Fri, 08 Dec 2006 08:41:51 +0100

Finally, I’m able to publish my graduation thesis. It was a secret document at first, because we were in the process of patenting the idea. Now that that’s done though, I can finally put my thesis online!

Enjoy reading Sadako: securing a building using IEEE 802.11. Here is the abstract:

This paper describes the Sadako project. It is a system for securing a building by using IEEE 802.11 network technology to determine the position legal occupants of said building. The alarm will be turned off in zones where those legal occupants are located, and turned on in other areas.

Most people know IEEE 802.11 simply as WiFi.

DoS attacks on DNS servers

Thu, 07 Dec 2006 07:52:06 +0100

Since last Friday, there have been DoS attacks on the EveryDNS servers, which also host my domains. So if you have had trouble reaching this website, you at least know why. Unfortunately, there is nothing I can do about it except switch DNS providers. Since EveryDNS generally fulfils my every DNS need, I’m not very eager to do that. If possible, I’d rather just wait things out.

Idefisk without fuss

Wed, 29 Nov 2006 20:14:57 +0100

Idefisk is an IAX Voice over IP client. It’s a nice little program that runs without fuss. The only thing that’s bugging me a bit is its installation procedure in Linux. You have to unpack a tarball, then copy a library to a system directory (as root), then run a command (as root) and then you can start Idefisk.

I generally don’t want to mix third-party libraries with system libraries nor do I want to execute anything as root unless I really have to, and there is no reason why you should. Idefisk can run just fine without performing any command as the root user. Place the below script in your Idefisk dir, make it executable (“chmod +x idefisk.sh”) and run it. No more root required!

The contents of the script are quite straightforward:

#!/bin/bash

export LD_LIBRARY_PATH=$(dirname $0)
$LD_LIBRARY_PATH/idefisk

Sound card ordering in Ubuntu

Sun, 05 Nov 2006 18:03:13 +0100

UPDATE 2019: unfortinately the article I link below has been taken offline, and by now I have no idea what was in there.

After I got myself a nice new motherboard, Ubuntu thought the onboard sound card should be the main sound card used by all applications. Since I’m the happy owner of a superior PCI card, this was quite annoying. Fortunately, I ran across the article Multisounds that clearly explains how to fix the ordering. After following the instructions, I had my PCI sound card back as the default. Total fixing time: 60 seconds.

In my humble opinion, selecting the primary sound card should be easier. Even in Windoze it’s as simple as selecting the sound card from a dropdown list. Maybe some day I’ll write something…

Spam filtering with Postfix

Sun, 15 Oct 2006 19:38:29 +0200

UPDATE 2019: the link below is unfortunately dead.

I’m moving from Exim to Postfix, most of all because of the simplicity of Postfix’ configuration files. Most HOWTOs about spam filtering with Postfix combine it with virus-scanning and other helper software like Amavis. All I wanted was plain spam filtering - perhaps virus-scanning will be added later, but for now i want simplicity. The document Postfix and Spamassassin describes this in just the way I wanted.

Article about OpenOffice.org and Python

Tue, 05 Sep 2006 22:27:27 +0200

The two small snippets I wrote two days ago were well received in the Python Usenet group. With the danger of being called a hero I proceded and wrote a proper article about OpenOffice.org and Python.

It contains the following sections:

Preparation
Gaining access to a document
Getting to the data
Converting from/to Excel or to PDF
Processing all files in a directory
Automatically starting OOo
More information

Enjoy the article!

Article about the Zaurus SL-C3000

Mon, 04 Sep 2006 00:06:16 +0200

I’ve had a productive day today! Because I wanted to do some testing with the original Sharp software of my Zaurus SL-C3000, I had to re-flash it. I took a risk that turned sour, so I had to clear the entire machine and start from scratch. It took quite a few searches on Google and a couple of downloads to get everything I needed. To prevent me from having to search all over again, I took the liberty of combining the info into a single page, including the downloads.

The article contains four small step-by-step HOWTOs:

I hope everybody that likes to tinker with their C3000 enjoys this collection of HOWTOs.

OOo spreadsheet to Excel with Python

Sun, 03 Sep 2006 18:13:45 +0200

UPDATE 2019: It seems that the website containing the library required by the below code is down. As such, it’s not really useful anymore.

A guy named Alf asked me on Usenet about saving OpenOffice.org spreadsheets to Excel files, using Python. After some more digging, this is what I came up with:

#!/usr/bin/env python

'''Demonstration program for saving an OpenOffice.org spreadsheet as
Excel sheet. Sometimes people refuse to install OOo, even though it's
completely free...

Requires that OOo is started with:
    ooffice "-accept=socket,host=localhost,port=8100;urp;"

Then open the spreadsheet as usual, and run this Python script.

Also requires Danny's OOo lib from
    https://www.oooforum.org/forum/viewtopic.php?p=56015
'''

import Danny.OOo.OOoLib as OOoLib
import unohelper

# For PDF output change the filter to:
# OOoLib.makePropertyValue('FilterName', 'writer_pdf_Export'),

properties = (
    OOoLib.makePropertyValue('FilterName', 'MS Excel 97', -1, 0),
)

filename = '/tmp/test.xls'

path = unohelper.systemPathToFileUrl(filename)
desktop = OOoLib.getDesktop()
doc = desktop.getCurrentComponent()
doc.storeToURL(path, properties)

As with the other script, this one requires Danny’s OOo lib.

Getting data from an OpenOffice.org spreadsheet

Sun, 03 Sep 2006 14:14:14 +0200

UPDATE 2019: It seems that the website containing the library required by the below code is down. As such, it’s not really useful anymore.

There is an easy way to get data from an OpenOffice.org spreadsheet using Python. Behold the following simple program. It allows you to simply get the contents from certain cells and handle them as you wish. I’m using this to fill a database with customer-supplied data in a spreadsheet.

#!/usr/bin/env python

"""Demonstration program for obtaining data from an OOo
spreadsheet.

Requires that OOo is started with:
    ooffice "-accept=socket,host=localhost,port=8100;urp;"

Then open the spreadsheet as usual, and run this Python script.

Also requires Danny's OOo lib from
    https://www.oooforum.org/forum/viewtopic.php?p=56015
"""

import Danny.OOo.OOoLib as OOoLib

desktop = OOoLib.getDesktop()

# access the current document
doc = desktop.getCurrentComponent()
sheet = doc.getSheets().getByIndex(0)

row = 0
while True:
    name = sheet.getCellByPosition(0, row).getFormula()
    email = sheet.getCellByPosition(1, row).getFormula()

    if not email:
        break

    print '%30s %20s' % (name, email)

    row += 1

As stated in the docstring, it requires Danny’s OOo lib.

I had to do a lot of digging to create this very simple program. The OOo API documentation is very complex. Hopefully this will simplify things for a lot of people!

DVDInfo version 1.1 released

Sun, 13 Aug 2006 11:05:13 +0200

UPDATE 2019: DVDInfo is offline. For converting DVDs and Blu-ray disks to an open format I would suggest MakeMKV.

A new version of dvdinfo has seen the light of day. For those who don’t know it, it’s a piece of software that enables you to find the track number of the main feature film on a DVD, along with audio and subtitle track information. This is a very easy tool if you want to rip a DVD to another format.

The changes are:

Only consider a title the main movie if it has an audio track. This ensures that picture-titles with one chapter per picture aren’t considered the main movie, even though such titles can have a lot of chapters.
Added the ability to specify which title to read.
Display 1/? instead of 1/1 if the total number of titles is unknown.

Check out the latest release of dvdinfo today!

Ethernet numbering in Ubuntu

Thu, 10 Aug 2006 10:35:32 +0200

update: this info is obsolete as of Ubuntu Gutsy (7.10). ‘Bogdan’ posted a comment with an approach that works on more modern Ubuntus:

In recent Ubuntu versions (and potentially other Linuxes), the iftab file is replaced by /etc/udev/rules.d/70-persistent-net.rules

(The 70 might change, though.)

It’s not the same syntax, but you can tell rather easily what it does.

My girlfriend’s laptop got bricked, so we replaced it with another laptop of the same make and model, and put in her original laptop’s harddisk. Of course, Ubuntu ran fine, but there was one issue: instead of having eth0 and eth1 as WiFi and LAN devices, we had eth2 and eth3. For some reason, Ubuntu refused to re-use eth0 and eth1.

After a bit of digging, I found out that /etc/iftab contains the MAC addresses of network cards:

# This file assigns persistent names to network
# interfaces. See iftab(5).
eth0 mac 00:01:de:ad:be:ef

This is very useful if you have hot-pluggable NICs that need to keep the same ethX every time you plug them in. Ubuntu’s installation put in the MAC addresses of the original network interfaces, so that’s why the new hardware skipped eth0 and eth1 and used eth2 and eth3.

Setting the correct MAC addresses in /etc/iftab solved the issue.

Two-way tunnelling with NetCat

Thu, 10 Aug 2006 10:25:50 +0200

I read this on the comp.lang.python newsgroup. It’s a way to have two-way tunnelling with NetCat. Thanks to Rob Haswell:

$ mknod backpipe p
$ nc -l -p 8080 < backpipe | nc other 8080 > backpipe

Move to mod_python

Fri, 04 Aug 2006 12:49:47 +0200

The www.stuvel.eu website has been moved from the Django development server software to mod_python. It should be more stable and also perform a bit better, especially when under heavy load.

Problem with IMDB-Compare

Thu, 20 Jul 2006 19:23:28 +0200

UPDATE 2019: All of the below is offline. However, IMDB themselves have similar functionality.

When you think “their HTML hasn’t changed in years”, their HTML changes. IMDB now features small images next to the author’s names. Nice to look at, but it did break IMDB-Compare. No worries, though, I’m already on it trying to fix things.

Edit: It’s fixed!

Fighting comment spam

Wed, 12 Jul 2006 12:43:06 +0200

The site has the possibility to add comments, and after a few days, the spamming begins. I’m curious if the automated spambots are smart enough to do some math. The captcha I’ve created is very simple: just give the answer to “1+1”.

Interview published

Fri, 07 Jul 2006 09:46:00 +0200

UPDATE 2019: the entire website www.studeren.uva.nl has been taken down, so also the interview is nowhere to be found.

I got interviewed for the University of Amsterdam. The interview has been published on the website for potential new students of the university. The interview is in Dutch.

Added comment ability

Tue, 04 Jul 2006 01:51:00 +0200

It is now possible to comment on news items! Soon I’ll also add backlinks from software and articles to relevant news items, so you can easily find the comments or post your own. Hopefully this will add some interaction to this website. I love to know what you think of it!

For some reason this post attracts a lot of spammers, so commenting on this particular post has been disabled.

UPDATE 2019: I’ve converted this website to (Hugo)[https://gohugo.io/] and removed the ability to comment on posts.

Converted my site to Django

Wed, 28 Jun 2006 13:14:00 +0200

The automatically generated web-based admin of Django made me switch :) Django is easy to work with, is built in a very modular, structured way, which really appealed to me. It took me only a couple of hours to convert my website to its template/engine structure.

There are two things that still need to be converted - the search engine and the news archive. Don’t worry, they’ll be online again soon!

edit: the archive is online.

edit: the search page is online too!

UPDATE 2019: I’ve converted my website to Hugo, and the above URLs are no longer valid.

Finished my study!

Tue, 27 Jun 2006 20:40:00 +0200

I finally finished my study! In two weeks, I’ll oficially be a Bachelor of Computer Science! It’s really weird to be done studying, since I’ve done that for nearly all my life. Good to have an official title :)

We won first price!

Fri, 23 Jun 2006 12:20:00 +0200

Science Park Amsterdam organized a contest for new ideas. We joined the competition with my graduation project Sadako, and won first price! Unfortunately, I can’t go into detail about Sadako, since that would get in the way of obtaining the patent ;-)

For more information, check out Science Park Amsterdam Nieuwe Ideeën Prijs uitgereikt (Dutch).

Another article appeared: UvA-medewerkers winnen Science Park Amsterdam Nieuwe Ideeën Prijsvraag. Also in Dutch.

DVDInfo

Mon, 12 Jun 2006 21:05:00 +0200

UPDATE 2019: DVDInfo is offline. For converting DVDs and Blu-ray disks to an open format I would suggest MakeMKV.

Ever wanted to rip a DVD with Mencoder? You would then need to find the right title number, the right subtitle track and and audio channel ID. With DVDInfo this has been made really easy. Just run DVDInfo, and it will find the longest title on the DVD and display all audio and subtitle IDs, together with the language and audio format. With this tool, you can spend less time tweaking, and more time watching movies!

Take a look at the latest creation of Stüvel IT, DVDInfo version 1.0

Rop Gonggrijp on Dutch television

Wed, 07 Jun 2006 21:17:00 +0200

UPDATE 2019: Unfortunately the video has been taken down.

Internet pioneer, hacker and man with a good vision on the future. He was on Dutch television on the 24th of may. In the final minutes of the show, he talked about privacy and databases of personal information. I was so impressed by his words, I just had to share with the rest of the world.

About databases and human tracking

The video is in Dutch.

Multiblend 1.3 released

Mon, 29 May 2006 07:36:00 +0200

I’ve released a new version of Multiblend! Version 1.3 has the following improvements over the previous version:

Added possibility to select the scene to render.
Added nice level to the config possibilities.
Added possibility to skip node testing.
Fixed chunk size bug when number of nodes is larger than number of frames to render.
Fixed encoding bug when stdout is not a terminal.
Start ‘sh’ immediately on the node. This prevents ’last logged in on …’ messages ologin, and thus improves compatability with different systems.
Added echoing_node to the config possibilities.

Multiblend connects to multiple computers on your network, and lets Blender render in parallel on each. This will drastically improve your rendering speeds!

IMDB Compare

Sun, 28 May 2006 21:53:00 +0200

UPDATE 2019: All of the below is offline. However, IMDB themselves have similar functionality.

Something I’ve always missed in the Internet Movie Database is the ability to compare two movies. Sometimes I forget an actor’s name, but I do know at least two movies he or she is in. With Stüvel IT’s IMDB Compare, everybody can compare two movies and get a list of actors that star in both. All you need to do is copy & paste two URLs and hit a button! It can’t get simpler than that.

Go ahead and try it yourself or look at our example first.

Two-pass MPEG4 encoding with mencoder

Tue, 23 May 2006 14:18:00 +0200

I keep forgetting this, so I’ll put it here for everyone (including me) to see:

mencoder dvd:// -o movie.avi \
  -oac mp3lame \
  -ovc lavc -lavcopts \
  vcodec=mpeg4:mbd=1:vqmax=10:lmax=10:keyint=130:vpass=1:turbo \
  -sid 3 -aid 130 \
  -vf scale=720:405,expand=720:576:0:25:1 \
  -spuaa 4

For the second pass, change vpass=1:turbo to vpass=2.

Tried Plone, but it's too much

Sun, 14 May 2006 21:42:00 +0200

UPDATE 2019: UnrealTower has been down for quite some years now.

This weekend, I took a good look at Plone. It’s a very nice content management framework for creating websites. It’s written in Python, easy for users that want to publish articles without knowledge about HTML and databases, and quite easy to get going. Besides that, you can manage your website entirely from the comfort of your own website.

The downside however, is that it’s tricky to customize the HTML and the CSS. The supplied HTML/CSS is quite large too - a simple page is about 235 Kbytes. Compare that to the 16 Kbytes of my current pages. My engine is a lot simpler, but therefore also a lot faster. The HTML is also much simpler, therefore it is a lot easier to get the looks I want.

Adding up the pros and the cons, Plone is nice, but personally for me, it can’t measure up to my UnrealTower Engine.

Multiblend version 1.2 released

Wed, 10 May 2006 15:28:00 +0200

Multiblend version 1.2 has been released. With this version, NFS is no longer required, so the usage has become a lot easier. There are now only two requirements left: be able to SSH to the nodes without password, and pack all required files into the .blend file. That should be easy!

If you’re upgrading from previous versions, please note the configuration file format has changed a little bit. The path to ‘scp’ needs to be set, and instead of ‘projectpath’ the nodes now have a ‘workdir’ option. It should be fairly easy to get things going.

Multiblend

Sun, 30 Apr 2006 22:25:00 +0200

For all the people that want to have an easy way to use distributed rendering with Blender, I have the solution: Multiblend. It is a Python script that feeds chunks of frames to each computer on your network, allowing them to render in parallel and greatly improve rendering speeds.

Multiblend is a Python script that needs only a simple configuration file and a well setup network. Of course, instructions on how to install and use it are on the Multiblend page.

Blender game engine on Ubuntu

Fri, 14 Apr 2006 10:19:00 +0200

I’m learning how to work with Blender’s game engine. Unfortunately, as soon as I press ‘p’ to start the engine, Blender crashes with a segmentation fault. Fortunately, I’ve found a way to fix this on Ubuntu Linux.

Install the dynamically linked version of Blender from the Blender website.
As root, type “apt-get build-dep blender”
Run Blender.

Online!

Mon, 10 Apr 2006 16:47:00 +0200

Finally, the Stüvel IT website can be reached by everyone. I’ve moved a lot of content from UnrealTower to this site, because this is a better place for it. I hope everybody enjoys my new site!

Stuvel.eu finally online!

Sat, 08 Apr 2006 13:49:00 +0200

Fortunately, stuvel.eu became mine. Welcome to my new domain! It’s nice to finally have a personal domain :)