Following on from my last post, I downloaded jBrout v0.2.109 to give it a whirl. Despite the name, it’s a Python/GTK application but feels fairly slick. The RPM didn’t work on FC5 (complained about a missing “userenv” dependency) so I installed from source; the entire distribution unpacks into a self-contained directory and only a small wrapper script (extracted from the RPM) is required to run it. Note that while the jBrout site has a support forum, much of the dialogue is in French, reflecting its author’s origin.

[Following this review, the author of jBrout, manatlan, responded with some observations and corrections, which have been inserted below where necessary.]

Importing existing folders of images and tagging them is fairly straightforward in jBrout. Tags can be grouped into categories, although this organisation is only used within the application and does not carry forward to the image tags themselves. New tags and categories can be created easily by right-clicking. After importing a folder (for which jBrout preserves its existing hierarchy in the filesystem), thumbnails for all the JPEG images are displayed (unfortunately, jBrout doesn’t recognise other image types; possibly this is a dependency on the Python libraries used, but it would be nice if at the very least it treated raw NEF files as TIFFs and processed them too, as KDE can do). The thumbnail size can be varied using a slider, to show more on-screen at once. However, if the thumbnail previews are generated at a small size and later expanded, they pixellate; i.e. the resolution used depends on the thumbnail size at generation time. [This is a known bug and will be fixed.] Also, the orientation data is ignored for thumbnails, although it is used when displaying a full image (by double-clicking any preview). [This is the fault of my image rotation utility, gthumb, for not also rotating the embedded thumbnail. jBrout can fix this by rebuilding the thumbnail.]

Images can be tagged simply by selecting one or more and then dragging the appropriate tag over them (although jBrout sometimes fails to register the click-and-drag action and it has to be repeated). Unfortunately, although you can select multiple tags, you can’t drag them. Tags are placed into an IPTC ‘Keywords’ field (there appear to be other standard or commonly used IPTC data such as location info and credits but jBrout doesn’t implement these; it isn’t a generic IPTC editor), and also logged in jBrout’s central image database. However, while the image file is updated at once, the database file is only written on exit so if jBrout or your session crashes, you lose the changes (you can rebuild it from the images, but more robust save and recovery would be preferable).

You can select whether to display the filename, album name, date or tags under each preview image but unfortunately not several of these items at once. If the data has too many lines, it appears to encroach on the preview image space and minor redraw corruption occurs.

Obviously, jBrout has a powerful search utility to locate images by tags (AND/NOT but not OR), format or date, although not name (you’re supposed to allow jBrout to rename your images to a datestamped format and search by date, which seems overly prescriptive to me). The Find dialogue disappears and is reset between searches, which makes it difficult to perform and refine iterative searches. [Likely to be fixed soon.] You can also use the ‘Time’ tab to locate all images from a particular month, after which the lead thumbnail for each date is shown in the left hand column; a nice touch if you wish to locate a particular shoot.

Obviously, if you want to tag raw images then the only solution is to tag matching JPEGs with jBrout and use a utility like exiftool to copy the Keyword field to the raw file. (Annoyingly, it seems that Bibble ignores and strips out this extra field when converting raw files.)

Additional problems, limitations or missing features that would be good to have:

• There’s no way to open an image in another application, such as an image editor. [This feature will be addressed via a plugin.]
• The ability to apply multiple tags at once, as mentioned above, would make tagging even quicker. [This can be achieved by middle-clicking the tags to select and then, while holding the button down on the last one, dragging them across to the image(s). Eventually, it will be possible to apply common sets of tags via identifying ‘keys’.]
• The list of available tags can quickly grow longer than the display, leading to a lot of scrolling. Perhaps the ability to type in a list of tag names (with completion) might alleviate this and support the multiple tags capability above.
• The tag list is displayed in the order in which the tags were added and resorted alphabetically for each category on startup. They cannot be resorted, neither can tags or categories be renamed (which makes cautionary sense for tags if you’ve already applied them to images, but the capability could be useful in other circumstances). [Something will likely be done to address tag ordering.]
• It would be nice if tag searching was combined with the ‘Tags’ tab, so that selecting several tags and then choosing ‘Find’ would display all matching images. [Was in v0.1, will possibly by reimplemented.]
• It may be useful if the tag categories were also stored in the IPTC data; e.g. as a hierarchy. Not sure if this would be practical or recommended practice, but I think I’ve seen it done by other apps (via “sets”)?
• The ability to display the complete EXIF data would be convenient, even if it was just the output of jhead in a dialogue box. [Possibly a plugin job.]
• jBrout doesn’t track any statistics based on image metadata; for example, the number of files matching each tag (although the total is displayed when you select a tag). This data would appear to be relatively trivial to extract from the database.
• The lack of raw file support is a real issue for users with anything more than a low end digicam. As discussed, this may be a limitation of the underlying Python libraries. However, the JPEG limitation is clearly also hardcoded into the application (e.g. it’s the expected filename extension).
• Allied to the last point, I have some concerns about the quality of the jBrout code. For example: when applying a comment to an image, jBrout attempts to write the text out to a temporary file called tag.txt so that it can insert the comment from the file by running jhead. This file is written in the execution directory, which will be where you installed jBrout. However, the user running jBrout may not have permission to create files in this directory (particularly if they’ve installed it in a system directory; e.g. via RPM). Furthermore, there is a race condition here that could be exploited. A quick Google indicates that the correct way to use temporary files securely in Python is via the tempfile module. Caveat emptor. [A fix for this is in v0.2.111. jhead will eventually be replaced with native Python APIs.]
• At this point, I’m not sure if jBrout creates IPTC data that is wholly standard (if such a concept exists), as complete as it might be or compatible with other applications (although the Keywords field certainly seems to be a defacto standard). That is partly a reflection of the relative immaturity of IPTC tagging (which needs wider adoption ASAP, as it fulfills a major need) and the lack of experience that developers (not to mention users!) have with it. The ability to add and edit other common IPTC fields, or even generic ones, would be useful here (perhaps via a templating or text editor function)? XMP support would be great, but let’s not get carried away with crazy dreams.

In fairness, I’m probably asking too much here. jBrout is presently a straightforward little graphical utility for tagging and searching images; the changes above may require a lot more work and would turn it into a pro-level tool. jBrout is simply the application that comes closest to that ideal at the present time.

If you’re running Linux and need a quick, easy way to tag and search your JPEG images - even if you have several thousand of them - jBrout is a good solution today. (Note that I’ve missed out several features of less interest to me, such as HTML & Flickr exports.) It’s also under heavy development so by v2.0, it could be light years ahead of its current state. Whether we’ll have something equivalent to Lightroom or Aperture any time soon appears less certain.