In working with old VW’s you end up looking at a lot of… old VW stuff. I assume this is true of most things you do, you end up looking at historical info to get an idea where to take the next step.

Sometimes this leads you to the most boring series of endless searches that yield nothing, but sometimes you luck out and find what your looking for and can even be pleasantly surprised along the way:

Interestingly enough I arrived at the reason why I was looking in these old brochures in the first place… the hose layout for my 1963 :)

It’s nice when you can get period correct info from a sources that are so inspiring. You can check out more at thesamba.com

I subscribe to the bicycle frame builders mailing list and like most good mailing lists threads can go on forever and get mired in details or tangents. Occasionally things jump out at you as important and this post by Elliott McFadden did and I thought I’d pass it along:

I listened to a product liability attorney talk about the difference
between the American and European systems of consumer protection. In
America, we keep regulations relatively light and underfund enforcement
then let lawsuits do the real heavy lifting. In Europe, regulation is
higher and enforcement well staffed and financed while large lawsuits are
relatively rare.

As a citizen and a business owner, I’d rather have the European model. It
seems more predictable and less expensive in the long run. Plus
governments are usually the only ones with the resources and time to
regularly take on real abusers with deep pockets.

Old lens’ on newer cameras, what a cool concept. I love the results as well. It goes to show that as the accuracy of the recording medium goes up (ie. 21Mpixels for the 5dm2) the more the lens quality and character make the difference in the end photo… now to hit up some old camera stores!

It’s only fitting to give an update on today 9/20/10, which happens to be my bus’ 48th birthday.

To celebrate, I worked a bit on the headlight buckets.  This is the driver side bucket, which has some rust in a few areas due to the elements.  The rubber seals were very brittle and may have never been changed.  Now 48 years later it’ll get it’s “eyes” cleaned up and converted back to 6v sealed beams.  I’ll be painting tomorrow after work.

Updates can be followed on my photo stream on flickr.

It is totally structurally unsound to do so, but man it looks cool:

• twisted floral pattern example
• instructable on how to do the above

I’ve thought of doing a few myself, but for a later time when I’m a more experienced wheel builder and I’d like some wall hangers.  Currently my most unorthodox builds have been a three leading / three trailing pattern on Mehran’s bike and a crow foot pattern on my Rebolledo track bike.

I wrote a few posts ago about the joys of converting a bunch of images into a pdf with a single command. Well I’ve been working with a set of tiff files files that Andrew Whitlock gave me for the oacdp project. The tiff files are a composite tiff’s meaning that they themselves are made up of a collection of tiff files.

My goal is to extract the tiff files, convert them to png, and then create a pdf from those pngs. I chose imagemagick because it’s been a great tool and is straightforward to use. I found that wasn’t quite the case for these files.

Firstly the tiff file needs to be broken into it’s component images

convert composite.tiff image-%03d.png

This produces a set of files that are named “image-000.png” and up.

Secondly the tiff files need to be assembled into a pdf file

convert images-*.png final.pdf

As discussed in my previous post, it’s not that easy because there is the issue of imagemagick’s poor memory handling when creating a pdf, so I used the pdfjoin technique from the previous post

pdfjoin --outfile final.pdf images-*.png

All is good.

Now enter an enormous tiff file, with 318 sub images that also brings it’s own set of issues with imagemagick. Often attempting to extract the sub images was causing my machine to completely freeze and kernel panic, which may be more of a kernel issue than imagemagick’s problem, but it was the immensely huge memory usage that brought it there, so I decided to learn another lesson from my previous post and I broke the job into many small calls to imagemagick rather than one large one.

Using my language of choice, I wrote a bit of lisp to do the decomposition of the tiff file, conversion to png, and assemblage into a pdf. Here it is:

;;;; Copyright 2010 Elliott Johnson
;;;; Distributed under the GPL - 3.0
;;;; http://www.gnu.org/licenses/gpl.html

(defpackage :net.elliottjohnson.lisp.convert
  (:use :cl
        :cl-user
        #+sbcl :sb-ext)
  (:nicknames :convert))
(in-package :net.elliottjohnson.lisp.convert)

(defvar *convert-binary*
  "/usr/bin/convert"
  "An acceptable name for the convert binary that's installed on your system.")
(defvar *identify-binary*
  "/usr/bin/identify"
  "An acceptable name for the identify binary that's installed on your system.")
(defvar *pdfjoin-binary*
  "/usr/bin/pdfjoin"
  "An acceptable name for the pdfjoin binary that's installed on your system.")

(defun acceptable-exit-code (process)
  (when (= 0 (process-exit-code process))
    t))

#+sbcl
(defun image-count (multi-image-filename)
  (let ((process (run-program
                  *identify-binary*
                  (list multi-image-filename)
                  :output :stream
                  :error nil)))
    (if (acceptable-exit-code process)
        (let ((file-count 0)
              (stream (process-output process)))
          (if (input-stream-p stream)
              (progn
                (loop for line = (read-line stream nil nil)
                   while line
                   do (incf file-count))
                (1- file-count))
              (error "Bad Outputstream: \"~S ~S\" return ~S~%"
                     *identify-binary*
                     multi-image-filename
                     process)))

        (error "Failed to execute: \"~S ~S\" return ~S~%"
               *identify-binary*
               multi-image-filename
               process))))

#+sbcl
(defun simple-convert (source destination &optional args)
  (let ((process (run-program *convert-binary*
                              (if args
                                  (if (listp args)
                                      `(,source ,@args ,destination)
                                      (list source args destination))
                                  (list source destination)))))
    (unless (acceptable-exit-code process)
      (error "Failed to execute: \"~S ~S ~S\" returned ~S~%"
             *convert-binary*
             source
             destination
             process))))

#+sbcl
(defun join-pdf (pdf-file-pattern dest-pdf-file)
  (let ((process (run-program *pdfjoin-binary*
                              (list "--fitpaper" "false"
                                    "--outfile" dest-pdf-file
                                    pdf-file-pattern))))
    (unless (acceptable-exit-code process)
      (error "Failed to join pdf: \"~A --outfile ~A ~A\" returned ~S~%"
             *pdfjoin-binary*
             dest-pdf-file
             pdf-file-pattern
             process))))

(defun name-source-file (multi-image-filename current-count)
  (format nil "~A\[~D-~D\]" multi-image-filename current-count current-count))

(defun name-dest-file (dest-dir dest-prefix current-count dest-suffix)
  (format nil
          "~A/~A~3,'0D.~A"
          dest-dir
          dest-prefix
          current-count
          dest-suffix))

(defun convert-suffix-to-pdf (source-file)
  (format nil
          "~A/~A.pdf"
          (directory-namestring source-file)
          (pathname-name source-file)
          '("-density" "100%")))

(defun name-dest-files (dest-dir dest-prefix dest-suffix)
  (format nil
          "~A/~A*.~A"
          dest-dir
          dest-prefix
          dest-suffix))

(defun name-dest-pdffile (dest-dir dest-pdf-name)
  (format nil
          "~A/~A"
          dest-dir
          dest-pdf-name))

(defun create-pdf-from-images (dest-dir
                               dest-prefix
                               dest-suffix
                               dest-pdf-name)
  (let ((source-files (directory (name-dest-files dest-dir
                                                  dest-prefix
                                                  dest-suffix))))
    (loop for file in source-files
         do (simple-convert (format nil "~A" file)
                            (convert-suffix-to-pdf file)
                            '("-density" "100%"))))
  (let ((pdf-file-pattern (name-dest-files dest-dir
                                           dest-prefix
                                           "pdf")))
    (join-pdf pdf-file-pattern
              (name-dest-pdffile dest-dir dest-pdf-name))))

(defun convert-multi-image-file (multi-image-file
                                 dest-dir
                                 dest-prefix
                                 dest-suffix
                                 dest-pdf-name)
  (let ((multi-image-count (image-count multi-image-file)))
    (loop for i from 0 to multi-image-count
         do (simple-convert (name-source-file multi-image-file i)
                            (name-dest-file dest-dir
                                            dest-prefix
                                            i
                                            dest-suffix))))
  (create-pdf-from-images dest-dir dest-prefix dest-suffix dest-pdf-name))

Currently it’s only extended to run on sbcl, but it would be trivial to have it work other places. The function to use is the last one and it’s used something like this:

(convert-multi-image-file "/path/to/my/file.tiff" 
                          "/my/dir/" 
                          "image-" 
                          "png" 
                          "final.pdf")

The end result is a pdf file and the png files needed for the project. The code makes use of the square bracket syntax of imagemagick to specify a particular file in a multi image file (such as a video file, pdf, or in this case a tiff). The Imagemagick FAQ is what eventually lead me to the technique.

This method can render everything out with little load in less than one minute for what used to rarely complete in over 45 minutes with massive loads (above 9).