Update: Background Scripts Plugin

22 Aug 2019

It would seem I have a poor understanding of what “available for download over the weekend” means, and after a couple months and a couple people asking about it I finally have the Background Scripts Plugin available for download.

The plugin reads the available scripts for the hosting version of Capture One, so future releases of Capture One won’t require updates to the plugin.

Landscapes and Glitches

13 Jul 2019

After my initial tests of using the field camera I knew I needed to find a sliding back in order for the camera to be used practically. Naturally that means turning to eBay. After some research I found a back that fit the bill, the descriptively titled “Movable adapter for Phase One Mamiya 645 Back to Arca Swiss 6X9”.

The new sliding back necessitated a new adapter for the Shirom. I opted to make an adapter that would take the Arca sliding back directly, rather than disassembling the whole thing.

One of the primary reasons I picked Arca Swiss is because of how simple it is to model. The adapter is simply a square with rounded corners with a light trap underneath.

Shooting

The flow of shooting with the adapter is much improved, only held back by a couple of minor issues which are simply a part of shooting with a view camera, old lenses, and a digital back.

That isn’t to say nothing went wrong. In my haste to get something printed out and working I used a translucent white plastic. It’s mostly fine, and probably only reduces the contrast a little 1. Unless light is directly hitting the adapter.

When the sensor can’t get a good dark frame to figure out when the exposure starts and stops weird things happen. I can’t be certain what happened in either of these images, but the results are, in their own way, kind of beautiful.

They remind me a little of messing with a Polaroid as it develops, where you end up with a unique photo created by altering the latent image.

After a few more tests, I did take some photos which exemplifies why I got this camera in the first place.

The photo above is a stitched panorama taken along Highway 46 on the Central Coast of California.


  1. The idea is to eventually mill the adapter out of aluminum. [return]

Background Scripts Plugin

12 Jun 2019

I do a lot of scripting in Capture One, but one of the features I never really use are background scripts. Capture One will call designated scripts when certain actions take place, currently:

Leveraging these scripts allows for some incredibly powerful workflows, if you can set them. Unfortunately the only way to set the scripts is with an AppleScript. The only way to know what script, if any, is set is with another AppleScript. The script itself is pretty short:

tell application id "com.phaseone.captureone12" to set capture done script to "/Script/location/script.applescript"

However, I wanted an easier option. Plugins were introduced in Capture One 12, and because plugins can display UI in preferences they’re the perfect way to show the background scripts.

The imaginatively named “Background Script Setter” plugin allows you to easily set, and importantly: remove, background scripts from within Capture One. This is something I hope to see Sherlocked by Phase One eventually. I’m still doing some polishing, but hope to have it available for download over the weekend.

Constructed Paper

02 Jun 2019

Over the weekend I decided to play around with some still lives to test out the new version of the field camera adapter. I’ve always enjoyed simple images of folded paper, and figured it would be the perfect subject. A quick trip to the craft store and I had a pack of colorful construction paper ready to go.

The 3D printed adapter works surprisingly well, given that it’s a pretty rough print. For the ease of shooting I do need to make an interrupt switch so the back isn’t triggered when I open the shutter to compose on the ground glass.

Overall I’m pleased with how the images turned out. The soft colors play well with the hard edges of the paper and the shadows add depth to the photos, which masks their scale. This is a subject I think I’ll return to. There are a few colors not used, and I’ve yet to explore complimentary colors.

This is one of my favorite images from the series:


Visit Constructed Paper…

Capturebot Beta Updates

20 May 2019

Capturebot is slowly inching closer to being ready for its release. Over the weekend I posted a new version of the beta that contains, as they say, “but fixes and improvments.”

This probably should have been done sooner, but the app now has a link to the website to make downloading the server a little easier.

I’ve also set up a Slack channel for reporting bugs & feature suggestions and even a Twitter account1.

Searching

With big shotlists searching is crucial. Equally important is being able to actually do things with the results. The swipe actions in search results will now perform their actions on the correct record.

Visuals

For anyone grouping by name the records now follow the more logical sort method if numbers are present.

The iPad now does a 5050 split so long record names aren’t truncated.

Beta

Check out the project page for more information and to join the beta!


  1. Which got suspended after a single day! [return]

Removing JavaScript

14 May 2019

My website has always been both a way for me to show my work & hobby for me to tinker with. Over the last year I’ve moved to self-hosting a staticly generated site and customized various themes within an inch of their lives.

Today I’m changing things up again. This time to remove JavaScript.

Inspired by a post by Brent Simmons talking about a web browser that disables JavaScript by default:

If it‘s the opposite — if I have to blacklist instead of whitelist — then I’d be constantly blacklisting. And, the first time I go to a site, it gets to run code before I decide to allow it.

It got me thinking about my website with its fancy masonry galleries, responsive navigation bar, and syntax highlighting and whether I needed JavaScript. As it happens: I don’t.

Unfortunately I am not a web developer, so I had to rely on cleverer people. After a lot of research and false starts1 I found some projects I was able to use:

  1. Masonry Gallery: Driveway
  2. Responsive Navigation: Luxbar
  3. Syntax Highlighting: Built into Hugo

With these components in place I also had a mostly fresh start and got to clean up the look of my site a little. The galleries are now first class layouts and all of the little overrides I’d made are integrated in the Hugo theme directly.

There are a few limitations to removing JavaScript. The main one for me is it reflows my gallery order. It’s not a huge issue, and it’s something that could be fixed with a small script, but I didn’t set out to remove almost all JS. I can always backpedal a bit, but it’s nice to not be reliant on it just to make my site work at all.

Blog Updates

I’ve also moved away from pagination on my blog. The main blog page will show a list of recent posts and the rest are at the new archive page.


  1. Shockingly, not everything posted on Stack Overflow works ¯\(ツ)[return]

Adapting a Digital Back to a 6x9 Field Camera

29 Apr 2019

Sometime last year I was up at my favorite camera shop, Seawood Photo in San Rafael, and saw a little wooden field camera, partially hidden, sitting up on the top shelf behind the counter. I asked to see it and instantly knew I had bring it home.

This little wooden 6x9 field camera is a Tachihara Shirom. While the movements are a bit limited both standards can be moved together to provide good support for wide angle lenses. The ground glass, which conveniently flips out of the way, is designed to take a Graflok roll film back, which is great if you want to shoot film. However, digital backs won’t fit the 2x3 Graflok back due to the where the film sits relative to the locking mechanism.

Luckily the whole ground glass assembly is removable! All one needs is an adapter to hold the digital back, easy, right?

Designing an Adapter

The initial version of the adapter was designed to use the original ground glass. I borrowed the Mamiya mount from an Arca adapter and got to work in CAD designing the adapter, which lead to the first problem: registration.

It’s difficult to find specs on the registration of Graflok film backs and nigh impossible to find measurements for digital backs. This left me with a pair of calipers and a lot of guess-work. After several attempts I did eventually (somehow) find the correct registration between the ground glass and the sensor.

The prototype I printed was a little bit on the thin side (I never got around to printing a reinforced version), but, with a few coats of black spray paint, completely worked. Taking a photo was simple:

  1. Compose & focus on the ground glass
  2. Remove the ground glass
  3. Attach the digital back adapter
  4. Attach the digital back
  5. Attach the sync cable
  6. Power on the back, if needed
  7. Take the photo
  8. Decide whether it’s worth reversing and repeating the process or guess about a composition change.

In summary, shooting this way was obnoxious. I ended up not using the camera much because it was just too much of a hassle.

The sensible approach is to get a sliding back. More on that later.

Adding a Counter to URL in Swift

02 Apr 2019

I recently ran into a bug in a project when attempting to move a file:

“The File.eip” couldn’t be moved to “.archive” because an item with the same name already exists.

This little error propogated all the way to the top and terminating my Launch Agent1. Being a background task I couldn’t ask the user what they’d like to do about this error, so the method moving the file had to handle it.

The obvious solution is to add a file counter to the end, so File.eip becomes File 1.eip. I figured it would also make sense to make this incrementing method an extenion of URL, similar to .appendPathComponent(:)

Adding a Counter

The whole method looks like this:

func incrementingCounter(starting count: Int = 1, by increment: Int = 1, format: String = "%01d", delimiter: String = " ") -> URL {
    
    // Break apart the URL
    let ext = self.pathExtension
    var fileName = self.deletingPathExtension().lastPathComponent
    
    let tempDest = self.deletingLastPathComponent()
    var counter = count
    
    // Find any suffix digits
    fileCounter: if let digitRange = fileName.range(of: "\(delimiter)\\d+$", options: .regularExpression) {
        
        let delimiterSet = CharacterSet(charactersIn: delimiter)
        
        // Extract the digits
        let subString = String(fileName[digitRange]).trimmingCharacters(in: delimiterSet)
        guard let fileCounter = Int(subString) else { break fileCounter}
        
        // Increment the counter
        counter = fileCounter + increment
        
        // Remove the existing counter
        fileName.removeSubrange(digitRange)
        
    }
    
    // Append the counter with a space
    let formattedCounter = String(format: format, counter)
    let newName = fileName.appending("\(delimiter)\(formattedCounter)")
    return tempDest.appendingPathComponent(newName).appendingPathExtension(ext)
    
}

and comes in two flavors:

The first constructs a new URL and the second adds the counter in place. The parameters allow the user to customize how the incrementing takes place. The user can specify the inital number, how much to imcrement by, as well as the string format of the counter and the delimiter to seprate the counter from the file name.

Let’s look at what each part does.

To find the counter we first break the URL apart so we can deal with just the file name.

let ext = self.pathExtension
var fileName = self.deletingPathExtension().lastPathComponent

let tempDest = self.deletingLastPathComponent()

Once we have the file name we need to check if it already has a counter. To do this I’m using a small regular expression, "\(delimiter)\\d+$", which matches our delimiter followed by number. The $ anchors the expression to the end of the string so we don’t match files that contain numbers in their file names.

Specifying the delimiter provides for more flexibility. By default it’s a space, but that may not always be what we need. I regularly work with files that use _v\d{4} as a counter.

fileName.range(of: "\(delimiter)\\d+$", options: .regularExpression)

This method returns an optional range for the matching characters. If there is a range we attempt to convert the range into an integer.

let delimiterSet = CharacterSet(charactersIn: delimiter)

let subString = String(fileName[digitRange]).trimmingCharacters(in: delimiterSet)
guard let fileCounter = Int(subString) else { break fileCounter}

The break here is important: it uses a labeled break which lets us exit the current scope (in the case our if for the range). I’m using the labeled break to handle the case where a number can’t be made into an integer2.

In this case it will just append a new counter to the end of the file name.

Next we increment the counter, and importantly, remove the existing counter.

 // Increment the counter
counter = fileCounter + increment

// Remove the existing counter
fileName.removeSubrange(digitRange)

The last step in our method is to format the counter and append it to the file name.

// Append the counter with a space
let formattedCounter = String(format: format, counter)
let newName = fileName.appending(" \(formattedCounter)")
return tempDest.appendingPathComponent(newName).appendingPathExtension(ext)

The whole file is available over on GitHub


  1. Now I have tests that try to copy a duplicate file. [return]
  2. I haven’t figured out how to write a test for this [return]

Laydown Test with Victoria Lau

10 Feb 2019

At the end of last year I partnered with stylist Victoria Lau to shoot another test, this time based around autumn and winter clothing.





Visit Autumn Laydowns

Scripting Collections in Capture One 12

21 Dec 2018

A few weeks ago Phase One released Capture One 12 with a slick new interface, support for plug-ins, and a fix for one of my pet bugs (I call it Ralph). There are also a handful of new properties that allow workflows to be automated.

With the release I’ve updated all of my scripts for Capture One 12.

User Property

Capture One collections include a new user property to help differentiate the session’s collections from a user’s favorites.

With this new property finding favorites is fairly simple:

tell front document of application "Capture One 12"
    set theFolder to captures
    set captureCollection to item 1 of (collections whose folder is theFolder and user is true)
end tell

This is also the key to making my capture folder navigation scripts work again.

Sorting

Another new feature is the sort order property, which allows a script to sort a collection by over a dozen different keys. The main use I’ve found for this is easy, automated batch renaming.

tell front document of application "Capture One 12"
    --  Sort by date
    set sorting order of current collection to by date
    set sorting reversed of current collection to false
end tell

Previously batch renaming was a multi-step manual process:

  1. Sort by the desired key
  2. Select all
  3. Reset the renaming counter
  4. Batch rename

All of these steps could be mapped to keyboard shortcuts, but who has time for that? A short script will do all of those steps in a single action. Paired with a few more lines of code, the script could move between all favorites and rename an entire session with in a single go.

Bonus: Progress Reporting

Anyone who has run a larger script that handles a lot of files has certainly run into the fact that Capture One blocks user input while a script is running. While this isn’t solved in 12, scripts can at least indicate they’re still running with the progress properties.

The progress is displayed in the same view as other Capture One progress bars.

tell application "Capture One 12"
    -- progress set up
    set progress total units to 10
    set progress completed units to 0
    set progress text to "Doing important things"

    -- for each task
    set progress completed units to progress completed units + 1
    set progress additional text to "Details about the important thing"
end tell

Impractical Practical Photography

20 Sep 2018


There is a lot of doom and gloom in the photo industry surrounding renderings taking over photography. Some of them are old hat, like Ikea’s catalogues, some are new like virtual Instagram influencers, and each one heralds the end of our profession.

Apple, recently, has been going the other direction. The wallpapers for the latest iPhones and Apple Watches are all real photos and videos1. Planets made of soap, nebulas from ink and paint, and physics replacing a physics engine with giant versions of watch faces.

In both cases using CGI might have been easier, but Apple instead chose to allow their photographers to experiment and play with photography in ways that aren’t often found in commercial shoots. The results are visually stunning and, perhaps, even whimsical.


  1. The iPhone wallpapers were even shot on iPhones [return]

Church in the Rain

18 Sep 2018

Friends from XOXO 2018

11 Sep 2018




1534 Stockton

19 Aug 2018

DT Capture One Scripts

08 Aug 2018

Over the past few months I’ve been working on a small collection of scripts for Capture One. They’re meant to make common actions on set easier, faster, and less distruptive to the shoot. Most of the scripts are paired with a keyboard shortcut for extra speed.

All of the scripts are availble on GitHub.

I’m always looking for more script ideas, so if there’s a C1 workflow you’re looking to automate get in touch.

Archive