A reader pointed out to me that the workflow described in Use Albums and Stacks To Manage Adjusted Images no longer works. Aperture 2.0 has changed the behavior of album picks so that creating a new album from non-pick images no longer automatically makes those images the album picks in the new album. Send feedback to Apple if you want the old behavior back.

Tags: Aperture, Bugs, Stacks, Album Picks, Workflow

Jürgen Banda-Hansmann has written a short series of articles about Aperture that cover:

• Optimize Libraries
• Optimize your folder structure
• Personalize and structure your Keyword List
• Create your own Metadata Presets
• Autostacking

Tags: Aperture, Blogging, Metadata, Keywords, Folders, Stacks, Library, Speed, Presets

If your workflow involves stacking before keywording then you have probably found that the keywording part is either inefficient or incomplete. Adding keywords to a closed stack only adds to the pick, so those non-picks remain without metadata.

There are consequences to this. For example, if I change the pick after keywording, the new pick (and hence the stack) no longer has the keywords:

The water keyword will not find the pick and so will not find the stack. And unless I specifically select to ignore stacks, any smart album that filters on the water keyword will fail to find this image.

The choice I have is either to live with this behavior, or keyword every image in the stack when I do the keywording. But how to keyword every image in a stack without going crazy?

The obvious way is to select the pick, click the number to open the stack, then click drag, click drag each keyword to each image:

This is very slow and error-prone. A faster way, but still with too many keypresses, is to open the stack and select all the images in the stack at once with command E. Then each keyword can be dragged over from the HUD just once to apply it to all the images:

I can apply multiple keywords at the same time by command-clicking on them and then dragging, saving even more time. And if the keyword buttons are set up on the keyword bar at the bottom of the window, I can press them or their keyboard equivalents to quickly apply commonly-used metadata.

I actually use an even faster way that goes straight to the next stack and opens it all in one step. First I select the top image in the project or album, then press option page down. That single key-press seeks forward to the next stack, opens it, and selects all the images it contains. Now I simply add keywords to all the images in the stack, as before. I press option page down again to go to the next stack and repeat. Once done, I close all the stacks with option semicolon.

Option page down also works in list view, but in list view the images are to small to be recognizable.

The option page-down method for dealing with stacks skips all the intervening unstacked images and that can be inconvenient. I have to go back over my images picking out the ones that are not in stacks among those that are in order to keyword them. I can make this a little easier by sorting the display by Keywords:

Once I do that, all the non-keyworded images are together at the bottom of the browser ready for keywording.

Tags: Keywords, Aperture, Stacks, Workflow

Thorne sent me a great tip for creating stacks: the order in which the images are selected is reflected in their order in a stack.

For example, I select these three images in the order right, top, bottom:

I hit command K to make a stack from them:

This can save time, since if you want to create a stack with the images sorted into rating order, there is no need to create the stack and the reorganize it. Just click on the images in the order they are rated and create the ordered stack immediately.

Tags: Aperture, Tips And Tricks, Stacks, Order

[Update: Aperture 2.0 kills this workflow dead. Apple has changed the behavior of album picks so that creating a new album from non-pick images no longer automatically makes those images the album picks in the new album. Send feedback to Apple if you want the old behavior back]

This article shows a powerful technique for managing adjustments to large numbers of images. It brings together stacks and albums and shows how they can be used as part of an efficient workflow. It was prompted by a posting on the Apple message boards for Aperture:

Here's the conundrum: I have 800 event photos in an Aperture project. I stamp adjustments to all of them. So, now I have 800 stacks, each with a master RAW image and an adjusted version. In each stack, the unadjusted master is the default pick. If the stacks are closed and I Export Versions, I get 800 JPEGs rendered from the unadjusted masters. If I open all stacks, select all, and Export Versions, I get 1,600 JPEGs rendered from both the masters and the versions. How in **** do I select the 800 adjusted versions for export without having to command-click on each one? Is there no way to automatically export just the versions?

The only approach I've found is to select the versions and make them the picks in their stacks, one by one. Then I can close the stacks, select all, and Export Versions. This is painfully time-consuming. I can't even just select the versions one by one and then batch promote them to pick status. I not only have to select the versions one by one, but I also have to promote them one by one. Argh! Am I missing something here? Please help.

Here is a project with some images that I am going to adjust. There could be thousands: the workflow is the same.

Before I start adjusting I select the three images I want to work with and create new versions by pressing option V:

This creates duplicates of the three and puts each duplicate into a stack with the original as the pick. This is where the difficulty lies as the person with the problem found. Since those new versions are in stacks but are not the pick then Aperture will not use the adjusted version for exports.

To turn this to my advantage (without clicking anywhere else so that the duplicates are still selected) I control click one of the new versions and select New From Selection > Album:

Pressing command L has the same effect. The new album is created and displayed and I can rename it to something meaningful, such as Adjusted:

The new album shows the stacks just as the project did, but this time there are check marks on the duplicates showing that these are the album picks:

An album pick is the image that will be on the top of the stack for this album only. Look what happens when I close all the stacks with option semicolon:

Just the album picks are left showing. That's the preparation complete. I have an album which will show me all the new versions, so no changes to the original project are needed. Now I adjust the images. For this example the changes are rather radical, so the difference is obvious:

I could have adjusted just one image and used lift and stamp to process thousands.

Selecting the original project shows that the adjusted versions are still in the stacks, and are not the picks as they are in the album:

Closing the project stacks will show me the originals. Closing the album stacks will show me the adjusted images. So by selecting either the project images or the album images I can choose which I export, print, or continue to process.

This technique can be used any number of times with any number of selections and albums and should be part of your standard workflow.

Tags: Aperture, Stacks, Album Picks, Adjustments, Workflow

Sorry to bother you again with a quick question. I've imported all my old images, and groped the similar shots into stacks, and closed the stacks to reduce the number of images shown. Now I'm going through and applying keywords, but the keywords I select are only being applied to the pick of the stack, not the whole stack. Any idea how to apply the keyword to the whole stack? I've tried the "primary only" toggle and that doesn't seem to be it.

Yes, metadata should really be a stack attribute, not an image attribute, but there is nothing we can do about that. The real answer is to set up your workflow so that you stack last. Apple seems to think that doing it first is the way to go but my experience is the opposite -- there are just too many gotchas. Do absolutely everything you normally do to your photos and then stack them. Or better still, stack only the good ones. There is usually no point wasting time on the one and two star images taken at the same time: they are still accessible simply by displaying thumbnails in time order.

To quickly access stacks (and only stacks) to apply metadata, do this:

1. Open all the stacks with option ' (apostrophe)
2. Go to the top with Home
3. Select one image in the first stack and press command E. That extends the selection, selecting all of the images in the stack
4. Drag keywords from the keyword HUD and they will apply to all of the images in that stack
5. Hit option Page Down. That takes you to the next stack and selects all of its contents.
6. Repeat steps 4 and 5 as many times as you need
7. Close all the stacks with option ; (semi colon)

Tags: Aperture, Stacks, Keywords, Q&A

I'm very new to Aperture, and am still struggling with stacks, though. My problem is that I'd like to put multiple versions of a single photo in a stack, cropped for different print sizes (with keywords of "5x7", "8x10", &c). But I also want to use stacks for selecting the best shot of several similar ones. My problem comes when I want to do both: Stack several shots together, but have multiple versions of the "pick." How do you do this without getting very confused?

[Update: A reader pointed out to me that filters on regular albums do include stacks that have members matching the filter. This behavior is not the same as projects (no match) or smart albums (match and extract images). I have amended the article to include this].

It is not obvious, but Aperture already does this for you: if you put images in a stack and then create versions, those versions are grouped with the originals. But there is a twist: if you leave the variations in the stack then a regular project filter cannot find them. The only way to find them is with an album: a smart album will find and extract the images; a regular album will find the images in the stack, but not extract them.

Look at this rather contrived example. Here are four images in a stack, with the pick on the left:

I want to manage two different crops of each of these. I'll make the crops really obvious so they can be distinguished in this example: one set of crops will be vertical and the other set horizontal. In real life they would have more realistic aspect ratios. I will start with the pick. I duplicate the version and drag it out of the stack (option drag does that in one step):

Then I crop it and keyword it:

Then duplicate the same original with option drag and crop it again, this time vertically, and keyword it:

Now I repeat that for the other images in the stack, just leaving them loose in the project:

A big mess. But that is OK because they are tagged and have the same file name as the originals. I can still find anything I need.

To find all the cropped images based on, say, the third image in the stack I have to do some filtering. Selecting that image and bringing up the inspector with control D lets me look at the file name (add the file name to the display using instructions here if it is not visible):

I copy the file name from the field: "Pine tree chopping22.JPG" and paste it into the project's filter dialog in the Other Metadata section:

And select is as the condition:

Here are the resulting images:

Notice that the original does not show up. That's because it is inside a stack in a project -- and only albums can see inside stacks. That is why I left the cropped versions loose in the project.

That found all of the crops based on one image, now what about the opposite: all of the images with one crop? To find all the horizontal images I filter on that keyword in the project. Since the cropped versions are loose in the project they are found:

Now let's do an experiment and see what happens if I tidy up the loose images. I select them all and hit command K to create a new stack:

Those grey rectangles inside the new stack have collected together images that are derived from the same original. What happens if I drag all of that stack into the original stack? This:

The originals and their versions are neatly grouped together! This is great, except that filtering the project on Horizontal now gets me this:

Nothing. Since this is a project filter and the pick does not match Horizontal, the whole stack is ignored. So I have to create an album.

A regular album will find any stacks that include the keyword, but will not extract the images. This tells me where to look, but not what to look at. In this case it is not very useful because every stack with a horizontal crop will be included along with all the other crops available in those stacks.

A smart album will match the keyword I specify and will extract the images. To create the smart album I select the project (important because I want the scope of the filter to be limited to that project):

And select the keyword I need, and check the Ignore Stack Groupings checkbox. That is the magic that lets the filter look inside the stacks and extract the images:

And as you can see, the four horizontal images have been displayed. But now I have lost my stacking information: which one was the pick? That is an inconvenient, but not unworkable problem.

So there are some trade-offs in the way that Aperture has implemented filtering and displaying stacks. I would do everything inside the stacks and have no loose images. I say that because the most important selection will be of the image. The crop follows. Once you have found the image in the stack that you want you can click on the crops and look at the metadata to pick the one you need.

Tags: Aperture, Q&A, Stacks, Adjustments, Versions

I often use each of several slightly different variations of an image for different purposes. I may use one as an original for my Canon S3 gallery, one as a quickly adjusted image for my desktop wallpaper, and one as a "made better" image for showing off.

How do I manage these variations? If I keep these versions in different places that are related to the way the image is to be used (such as in projects or albums), then how will I ever find all the variations of one image? If I keep them all together, then how will I know what purpose each is to be used for?

I solve the dilemma by putting all of the variations into a stack so they are grouped together and then using keywords to reveal their purpose. Here is an example:

The leftmost image has a caption, keywords, and ratings and it has been adjusted. That is my show-off image, so it is the pick. The center image is a copy of the leftmost image, but has different adjustments, including cropping. This one has an extra keyword attached: Actions > Wallpaper. The rightmost image is completely unadjusted and unrated. The only keyword attached is Actions > Bagelturf Gallery.

With my images all collected together into a stack, if find one, I find them all. To use them for different purposes I create smart albums, one per purpose. One of them looks for recent wallpaper images. As well as filtering on the Wallpaper keyword, it also has the following settings:

The date condition defines recent as shot in the last three months. The checkbox at the bottom is important because it allows this filter to look inside stacks. Without that the stack that I used above would hide the non-pick variations I want to find. I have a similar filter for Bagelturf Gallery that collects all the images that I post in the Canon S3 gallery.

To use one of the smart albums I just select it, let the images load, and then export the result, or use the associated previews.

As an alternative I could have not used a stack, but instead have tagged all the related images with a common keyword. But this quickly runs into trouble. I have to make all of my tags different, and when I have many images and just a few purposes, it is easier to tag for purpose than for image. Using versions names could work, but it is easily broken because version names are often modified.

Tags: Aperture, Stacks, Tips And Tricks

That's a stack, and on the left is the pick, the image that I actually want to use out of all the candidates. When the stack is closed, only the pick shows:

But there is another kind of pick supported by Aperture, an Album pick. Album picks are very handy because they let you have a different pick for each album (or gallery, etc.) that the image appears in.

If I open the stack again, duplicate the K twice (option V) and put those two K versions together in another stack, then put that stack in an Album by selecting the images and selecting New From Selection -> Album, I get this:

Working in the album and duplicating one of the versions I get this:

There is a check mark on the third image. That check mark shows the Album Pick. You can set and clear the Album pick from the Stacks menu (Stacks > Set Album Pick) or use command shift backslash. An Album pick allows you to have a different pick for each album that the stack appears in. This is useful because the context of each album may cause you to favor a different image for each one.

To illustrate this, I created a stack containing three versions in the Project called Stack. I made some adjustments to these three versions so that they are visually distinct; blue, yellow, and rotated:

Here is the same stack in an Album (note the check marked image):

And in another Album (note the different check marked image). I did this by selecting each Album making different images the album pick for the Albums:

If I close these stacks I get different results in each case. I get a stack in the Project with the blue image showing as the pick, as expected:

In the first Album I get the rotated image as the pick:

And in another Album I get the yellow image as the pick:

This shows the strength of stacks: they are a tool designed to defer choosing among interchangeable images to the point of use.

Tags: Aperture, Stacks, Album Picks

When you use stacks and also create new versions of images, Aperture does some interesting things. Versions are grouped together inside a stack if you put them there.

To illustrate this I'm starting with a stack of six simple images:

I make a new version from the K and apply some adjustments to get this:

Creating a new version using Duplicate Version (option V) gives me another version right next to it:

I didn't create that stack, but Aperture has done it for me. And this stack is different -- it has a light gray background inside the dark background. It has grouped the two versions for me. I can drag one of the versions out and have them as separate images if I like:

Duplicating versions that are inside a stack makes a version group inside it. Here I have duplicated the T:

And adding versions to a stack that contains the master or other versions of the master automatically creates a version group inside the stack, so putting all the versions next to each other. It's a little like siblings always wanting to sit next to each other when they are with others. Dragging the two Ks I made above into the stack gives me three Ks together:

And this brings up another way to magically make images vanish. Here is an album that contains just the two blue Ks. I created this when they were outside the stack. See there are (2) items in the album:

When I moved the two Ks into the stack and went to look at the album it showed empty -- but the Album still shows a count of (2):

I am not sure if that is a bug or a feature, but it is an easy way to lose images. There is no way to mark an Album to ignore stack groupings, and this is the result. It's not a filtering thing either. Filtering was set to show unrated or better. I also discovered that by using undo and redo you can get the Album to show the stack pick and not the Album pick.

Tags: Aperture, Stacks, Versions

Stacks feature heavily in the promotional material for Aperture, so I leaped upon them as soon as I had the application installed on my hard drive. The first thing I did was to autostack on import. That was problematic because I had to undo many of the stacks later. I had found that the rating system and the stacking system interact in some surprising ways, sometimes to the point of having images vanish in front of my eyes.

The other thing I did was to stack things (manually) that should never have been stacked. Then I could no longer see or find the stacked images that were "hidden" behind the pick. Another way to "lose" images.

The real reason for stacking is to simplify the management and display of images 1) where a number of interchangeable alternatives exist and 2) to defer image selection to the point of context.

So don't use stacks to group images together for any other reason. They are for fine-tuning, not for grouping arbitrary images. Use Albums and Brown Folders to make arbitrary groups. If you shoot sports, for instance, where only one image of a burst shows the impact of one thing against another, then stacks are not for you. That one image is not interchangeable with the others shot at the same time. But if you have four great pictures of the same person undergoing an impact during the same game, then do stack them. In that way you can defer your selection to the point at which the images are used. The images are interchangeable in that context.

Lets look at stacks in action. To use stacks, first import some images:

Make a selection:

Hit command K, and voila! a stack is born:

Look carefully at those three graphics. The first has six separate images. The second has six separate images with a thick line around the primary selection and thin lines around the rest. When you create the stack, it is that primary selection that goes to the left and is determined to be the "pick" of the stack. That's handy and will save you some effort.

The third graphic shows the stack created and open. The background is now dark around the six images in the stack. The 6 on the pick shows how many members there are; clicking on the 6 or hitting shift S gives this, a closed stack:

If you open a stack and select a member it looks like this:

Doing a Select Parent (Edit menu, option shift E) will create yet another display that shows the pick selected and the whole stack selected:

Within a stack the images can have any order; and contrary to many expectations, the order has nothing to do with the rating given to each member:

If you close a stack with rated images then the pick is the rating for the whole stack. The others are ignored:

This means that if you have images filtered to, say, two stars or better, and you change the pick to one star or promote another stack image that already has one star to the current pick, then the whole stack disappears without warning. Images that are in the stack are "protected" by the rating of the pick. So you can have a stack with lots of rejects, but the filtering doesn't make them invisible if it is set to one star or better.

And this is a problem if your images are autostacked on import. All those rejects don't disappear with filtering. So a better workflow is to find the rejects first and delete them, then autostack. But then autostacking is not as effective because there are gaps in the images.

You can still find images that are rejected if they are in stacks. Look at this Smart Album:

At the bottom I have checked Ignore stack groupings. That allows the filter to look inside the stacks. So there is a wholesale way of deleting the rejects where ever they may be.

Tags: Aperture, Stacks