This is the second part of an ongoing series of articles that will hopefully shed some light on developing an Aperture Edit Plugin. This series is not meant to be a tutorial, but more of a documentation of my personal efforts to create a plugin for use in a two year long art project I will begin working on this fall. This art project is also going to be documented over at my website called Entropy Art. Please feel free to check it out, sign up and participate in any way that you would like. Also, I am making the source code for this plugin available as open source. As it is still just basically a template, I haven’t felt the need to choose a license for it yet, but I will eventually. For now, please feel free to download the code and contribute any ideas you would like.

In the last part of this series I went through the very basic steps of creating a new project in Xcode. At the end I included a script that will allow you to run Aperture in debug mode so that you can debug your plugin using Xcode’s built in tools. However I made a slight mistake in the script.

If you notice the destination paths in the script all refer to Plug-Ins/Export. This was copied over from a previous project I had been working on that was an Export plugin for Aperture. For an Edit plugin, this should be changed to “Edit.”

What Will My Plugin Do

At this point I want to achieve two things. I want to get my plugin to the point where it will load up my selected Aperture images and display them in the UI, and I want to really start thinking of what it is I want my plugin to do!

The first task was pretty easy as the SDK comes with a sample edit plugin that I was able to use to copy most of what I needed. It is pretty simple, and we will be going over it in this article.

The second task is a bit more involved. Of course, this will all evolve over time, but I sat down the other day and started to dream up what I would like my plugin to be. I also drew out some sketches of how I would like to UI to look and feel and I have included them here for all to see.

A professor of mine once told me that all good ideas can be drawn on a bar napkin ( or three ), so that is what I did.

After thinking about it for a while and making some notes I realized that what I really want is something akin to a few other applications out there. In fact, these other applications are really languages themselves, designed so that the people who use them can create scripts. But I want to make things a bit more visual. So, this plugin will do a number of important things. It will expose to the user a slew of image processing functions in a visual manner. They will be able to select for example a filter and use some controls to apply it to their image. Once they have their settings adjusted they will be able to add this “function” to a “script.” This script is essentially a list of the user’s selected functions and settings. You should be able to rearrange them in the order you want, and you should be able to edit them as needed.

You should also be able to save your scripts so that you can apply them to other images in the future. To start out I plan to draw on the various “Image Units” found in the Core Image library. These are pretty extensive and allow for quite a bit of modification. In addition that what is already available you can create your own image units via the OpenGL Shading Language.

I haven’t yet decided how I am going to present the data to the user if their function results in a 1D data-set ( images are 2D ). But I may have some view available that presents the data as a graph or something. For example, lets say the user wants to crunch their image into a histogram representation. I should be able to display things like histograms as well as 2D image data, but for now I will focus on 2D image data.

The other applications that I am sort of trying to mimic with this plugin are things like Processing or IDL/PV-Wave. They are full-on programming languages in their own right, but they basically do some of the things that I am trying to do here.

Building Blocks

To get things rolling I decided to tackle task number one and get my plugin to the point where it can load an image and display it to the user. This was actually really easy thanks to the SampleEditPlugin that comes packaged with the SDK.

My first step was to create a very simple user interface. This would essentially consist of a view for the image, next and previous buttons and done and cancel buttons. Using Interface builder I was able to set this up in no time simply by dragging the controls over from the library.

To do this, I opened the file in the template with the .nib extension. This is the user interface file and you edit it with an application called Interface Builder. It should open automatically in IB if you double click the file.

Once open you will see a few things. First of all there is the main window that houses all of your main UI elements. It already has a few items in it including the following: Application, First Responder, Files Owner, and an NSWindow simply called EditWindow.

The main pieces we will be interested in working with for the moment are the NSWindow and File’s Owner.

If it isn’t already opened by default, double click the EditWindow and you will see it appear. At the moment, there is nothing to it. It is just an empty NSWindow. Our first order of business is to get it to display on screen when we call the plugin from Aperture.

To do this we need to wire up the EditWindow to our outlet we have in code. To do this we control-click and drag from the item called File’s Owner to the EditWindow. You will see it highlighted when you are on it in blue. Once you release the mouse you will have a small drop-down box that asks you what you’d like to wire this to–select the only item in the list called _editWindow. This tells the plugin code that the outlet called _editWindow refers to that NSWindow in Interface Builder.

I’m really not exactly sure how this all works under the hood. It takes some getting used to and some reading up on Xcode really helps.

Once we have this wired up, we can run our plugin. If we select an image in Aperture and choose Edit With–>Visualize, we will see the single window appear. Unfortunately, we haven’t given our plugin a way to quit at this point, so we are forced to kill Aperture and the plugin by clicking Stop in Xcode.

So our next obvious task is to add in the four basic buttons. I start out by opening the file in Xcode called Visualize.h. This name will vary depending on the name of your plugin. This is our main controller class for the plugin and will do most of the work of controlling our UI, amongst other things.

In Visualize.h there are already a number of items added by the template. Let’s have a look.

As you can see in this screen shot the Aperture template has added a generic object called _apiManager, an NSObject called _editManager, and NSArray called _topLevelNibObjects, and our outlet for the NSWindow called _editWindow. Below this I have also added outlets for our four buttons and the NSView we will be implementing.

These outlets allow the code to manipulate the properties associated with each control. For example, if I want to enable or disable the Next and Previous buttons, I need to be able to access their properties programatically. These outlets make that connection in our UI.

In order to respond to an event ( when a user presses a button ) I need to add a few “actions.” At the bottom of the Visualize.h file, I add the following:

IBActions are the methods that get called when a user clicks a button or changes a slider’s value. These are the declarations for our button actions.

Once we have added this code we can jump back over to IB and wire things up. To wire up the IBOutlets we simply control-click and drag from File’s Owner to the button we wish to wire up. When the drop down appears you simply select the outlet that goes with the button in question. Oh, and I guess I forgot to mention that you need to add the four buttons to the NSWindow. Just drag them over from the library. You can also double click them to change the text from “Button” to whatever you want.

To wire up the actions, we basically do the opposite. Control-click and drag from the button to File’s Owner and select the appropriate action.

Once you have done this for all four buttons you will be able to write code to control what happens when a user presses the button, and you can manipulate your buttons properties in code.

At this point all I also want to add my view for the display of the image. To do this I am going to use an NSView which I drag over from the library. I also will wire this up to the NSView outlet I have created in Visualize.h called _imageView. I can stretch out the view to make it fill up most of the screen, and once I am done it looks something like the screenshot below.

Now I can save my interface and head back over to Xcode. The next step is to add the actual code that will get called whenever someone presses one of the four buttons I have placed in the UI.

Here is an example of what the code for the Cancel button looks like.

The action for the cancel button needs only one line of code at the moment. [_editManager cancelEditSession] simply tells the plugin to quit and to return things to the state they were in before opening the plugin.

For the remaining buttons I will leave the code empty for now. The Next and Previous buttons will require some more code that I still need to write, and the Done button actually does quite a bit as that is when all of the newly processed images get saved to disk.

But at least we can cancel our plugin at this point!

So at this point we still aren’t displaying any images. The plugin doesn’t know how to do this yet. In my next article we will go over how to get the plugin to display images, and how to implement the Next and Previous buttons. Hopefully by then I will have a clearer idea of what I want my plugin to do and how I want it to look! Until then, feel free to download the code and try it out for yourself. You may see some code that I haven’t gone over yet, as I tend to write these articles a little behind the actual coding progress, but hey, this way you get a heads up!

Share This

PictureCode has released this week an Aperture plugin version of their very popular Noise Ninja. Noise Ninja provides users with high quality, camera specific noise reduction. The plugin will be available for download on their site as a free demo and a software key for the full version can be purchased for $79.95. Customers who bought earlier versions of the Pro Bundle can upgrade for $20.

When I heard about this new plugin I immediately got excited about one very specific thing–my Nikon D2H files! A few years ago I was one of the unlucky individuals who bought a brand new Nikon D2H. In hand the camera was remarkable. It shot at 8 fps, and had a seemingly never ending buffer, even when shooting Nikon’s raw format. It was built like a tank and could withstand just about anything I was able to throw at it.

However, the original Nikon D2H suffered in one area that was a deal-breaker for me–NOISE!!! This camera was simply awful at high ISO. It was especially bad in mixed, artificial light. As a Washington D.C. photographer, covering politics on Capitol Hill, I was nearly ALWAYS working in these types of situations.

To better illustrate what Noise Ninja can do for my old D2H files, check out this set I have created on flickr.com. I have posted 5 screen shots displaying a quick edit on an image I liked of former D.C. Mayor Marion Barry. Here he is speaking at a podium just after being sworn in as a D.C. Council Member–go figure.

In each screen shot I have added a short commentary about the noise issues and how Noise Ninja was able to help me solve them. If you are logged in to flickr, you can also see larger versions by clicking “All Sizes.”

After

So far I am pretty impressed with this plugin. The price is pretty reasonable, and the simplified interface is very welcome compared to the Photoshop version.

For more information, please check out the press release after the jump.

PictureCode releases Noise Ninja plug-in for Aperture

Austin, TX – August 5, 2008 – PictureCode today released the Noise Ninja plug-in for Aperture 2.1, Apple’s groundbreaking photo editing and management software. The Noise Ninja plug-in allows Aperture users to take advantage of powerful technology to remove noise and grain from digital images without having to leave Aperture.

“High-quality noise reduction has become an indispensable tool for the serious photographer,” states Jim Christian, founder of PictureCode. “As soon as Aperture was released, we started receiving requests to make Noise Ninja work with it. We worked closely with Apple, taking advantage of their new Software Developer Kit, to bring our solution directly into the Aperture application environment.”

“Professional-level noise reduction is one of the top requested features from our Aperture customers,” said Rob Schoeben, Apple’s vice president of Applications Product Marketing. “With the introduction of PictureCodes’ new plug-in, now Aperture users can have Noise Ninja right at their fingertips.”

Noise Ninja is ideal for low-light or fast-action shooting situations – including news, sports, wedding, and event coverage – where high-ISO photography is required and the resulting noise compromises the image. Using patent-pending technology developed by a former professor of computer science, Noise Ninja’s powerful, best-of-breed technology yields an unmatched balance of noise suppression and detail preservation, achieving natural-looking results with excellent avoidance of artifacts.

Pricing & Availability

Noise Ninja is available for download at www.picturecode.com/download.htm. The plug-in must be activated with a license key that can be purchased from the PictureCode website for US $79.95, which will activate all current versions of Noise Ninja. Customers who have an earlier version of the Pro Bundle key can upgrade to the new version for US $20.00.

About PictureCode

PictureCode LLC develops innovative software technology for digital photographers. PictureCode’s noise reduction technology is used by first-tier news organizations and professional photographers around the world, and Global 1000 companies have licensed the technology for applications in medicine and photography. Founded in 2003, PictureCode is located in Austin, Texas and serves a worldwide market via the Internet and more than 450 authorized resellers.

Share This

Nik Software Color Efex Pro™ 3.0 filters are the leading photographic filters for digital photography. The award-winning Color Efex Pro 3.0 filters are widely used by many of today’s professional photographers around the world to save time and get professional level results. Whether you choose the Complete Edition, Select Edition, or Standard Edition, you’ll get traditional and stylizing filters that offer virtually endless possibilities to enhance and transform images quickly and easily.

Check out all the details in their press release here.

Share This

You can read more about this at the website I have set up to document my project at Entropy Art.

Using an Aperture Edit plugin to manage my digital image processing makes perfect sense to me. I can create a suite of routines, have them be customizable in any way I want, and have them directly integrated with Aperture. This will keep my workflow simple and will keep all of my images and thesis work in one place.

As well, using Aperture allows me to take full advantage of all of the built in digital image processing libraries that come with Mac OS-X. These include the Core Graphics and Core Image libraries as well as OpenGL. In addition to these native frameworks I can integrate other very rich image processing libraries in Python using the Python Objective-C bridge.

In a nutshell, with an Aperture Edit plugin, I can create just about anything I would be able to do in a standalone application, but have it directly tied to my images and their metadata from Aperture.

As part of the Entropy Art project, this plugin will be written openly. I will be making the code available to all, and if you are a developer you will also be able to contribute to it and offer suggestions if you would like.

I have been writing Aperture Export plugins for some time now, but have never delved into an Edit plugin. I also don’t have the clearest idea of what it is I would like my plugin to do at this point. But, these things will come with time and with need.

So, I will be documenting this process here in a series of articles. Each article is not meant to be a tutorial exactly, but more of a documentation of my work. So please be prepared for some errors, some learning, and some missteps along the way.

Getting Started

The first thing I need to do is get my plugin template set up. Since I have been working with Aperture Export plugins I don’t need to do much, but if you have never done this before you will need to download the latest version of the Aperture SDK, which is available online at developer.apple.com. The SDK is free, but you must sign up at least as a free member for ADC.

Once you have downloaded and installed the SDK you can get started creating a template. In Xcode, select New Project from the File Menu and choose Aperture Edit Plugin under Standard Apple Plug-Ins.

For my plugin I chose the name Visualize. This creates a folder called Visualize containing all the files I need to get started. Xcode opens the project for me and I can see my list of files in the main part of the screen, along with my project’s “Groups and Files” in the left section.

In the next chapter of this series I will go over in depth the purpose of each of these files, but for now just notice the two main files named after whatever you called your project. In my case these are Visualize.m and Visualize.h. These are the files we will be working with for the most part, and will control most of what our plugin does.

Setting Up The Info.plist File

One of the first things we will need to do will be to make a few basic entries to our Info.plist file. This file contains a number of important properties having to do with our plugin. The one property we must edit is our unique identifier. Towards the bottom of the file you can see a group called ProPlugPluginList. If we open this up we can see a space that says “PUT A UUID HERE.” So first we need to get a new UUID. To do this, open a Terminal window and simply type “uuidgen” without the quotes. This will create a long sequence of letters and number which you can copy and paste into your Info.plist file.

I also change my Bundle Identifier property to reflect my company name, but this is about all we have to do at this point. Our plugin is now able to compile. To test it, we can hit the Build button and it should succeed without any errors.

If we want, we can even drag our newly built plugin into our Aperture Edit plugins folder and try starting it up in Aperture. However, going through this process every time you want to test your plugin can get a little annoying.

To make things easier we do the following steps. First we need to add Aperture as a new Custom Executable to our Xcode project. Simply control-click the Executables” tab under Groups and Files and select “Add New Custom Executable.” A dialog box will appear asking you to choose a file. Simply navigate to your Applications folder and select Aperture.

Next we need to add a script that will automatically build our plugin in the correct place and launch Aperture. To do this, click the tab in Groups and Files called Targets and then open your projects target so that you can see all of its build phases. Control-click the target and select Add –> New Build Phase –> New Run Script Build Phase.

A dialog box will appear. All you need to do is copy the following shell script into the dialog box as shown in the diagram, and close to dialog box.

# clean up any previous products/symbolic links in the target folder
if [ -a "${USER_LIBRARY_DIR}/Application Support/Aperture/Plug-Ins/Export/${FULL_PRODUCT_NAME}" ]; then
rm -Rf “${USER_LIBRARY_DIR}/Application Support/Aperture/Plug-Ins/Export/${FULL_PRODUCT_NAME}”
fi

# Depending on the build configuration, either copy or link to the most recent product
if [ "${CONFIGURATION}" == "Debug" ]; then
# if we’re debugging, add a symbolic link to the plug-in
ln -sf “${TARGET_BUILD_DIR}/${FULL_PRODUCT_NAME}” \
“${USER_LIBRARY_DIR}/Application Support/Aperture/Plug-Ins/Export/${FULL_PRODUCT_NAME}”
elif [ "${CONFIGURATION}" == "Release" ]; then
# if we’re compiling for release, just copy the plugin to the Internet Plug-ins folder
cp -Rfv “${TARGET_BUILD_DIR}/${FULL_PRODUCT_NAME}” \
“${USER_LIBRARY_DIR}/Application Support/Aperture/Plug-Ins/Export/${FULL_PRODUCT_NAME}”
fi

That’s about it. Now we should be able to select “Build and Go.” This will build our plugin and launch Aperture. Xcode will give us support for debugging in this mode as well, so it is a very useful way to work.

I try this myself and when Aperture launches I can see my Visualize plugin listed under “Edit With.” However, when I click it, nothing happens. This is because I haven’t told it to do anything yet. I still need to connect my user interface to my code, and I still need to tell my code to do something when I launch the plugin.

At this point however, I am ready to add my project to a revision control system like Subversion so that I can track all of my changes along the way. I can also take a look at the sample edit plugin that came with the SDK to get an understanding of how this should all work.

In the next part of this series we will talk a little about setting up revision control and then we will jump right into the first steps in designing and displaying our user interface, so stay tuned!

Share This

Share This

Italian software developer, DataMind Srl, has released Jade 1.0, a digital image processing plugin, which uses state-of-the-art algorithms to enhance color, contrast and dynamic range in an easy-to-use tool that will automatically improve digital images directly in Aperture.

Beside a “One-Button” automatic image enhancement tool, Jade also provides manual controls to fine-tune intensity values, the contrast of the image and the color correction for unbalanced images.

Jade Plugin 1.0 is offered in both Standard and Pro versions, and are available as a full-featured 30 day demo.

Jade Standard is €19.99, and Jade Plugin Pro is €49.99. A discount is offered to customers who have purchased a Jade 1.x application license.

Share This

When the dynamic range of a scene is beyond the gamut of a single exposure, Hydra can use multiple (different) exposures of the same scene (up to 4) and blend them into one image.

Unlike some HDR (high dynamic range) programs, Hydra does not require the use of a tripod to insure pixel-to-pixel matching of images. Instead, a method of matching key points in the images is utilized. For many example, see the Flickr HDR Pool.

Hydra is available as a demo, and can be purchased for $59.95.

Share This

The Tiffen Dfx digital filter suite is the definitive set of digital optical filters. Up to 1000 filters, including simulations of many popular award-winning Tiffen glass filters, specialized lenses, optical lab processes, film grain, exacting color correction plus natural light and photographic effects–are now in a controlled digital environment with either 8 or 16 bits per channel processing.

A 15-day free trial is available via download.

A quick video tour of the product is available here.

Share This

One of three Aperture plugins from Digital Film Tools, Power Stroke introduces a simple, interactive stroke-based interface to quickly and intuitively perform targeted adjustments. Instead of meticulously selecting regions or hand-painting masks, regions of interest are isolated by drawing a few simple brush strokes with adjustments then made only in those areas. Strokes can be assigned multiple adjustments and effects such as color correction, recoloring or desaturation, colorization of black and white images, blur, fill light for dimly lit image areas and Diffusion/Glow.

The $120 program is available as a “demo“.

See also Light 3.5 and Ozone 2.5 from Digital Film Tools.

Share This

One of three Aperture plugins from Digital Film Tools, Ozone is inspired by Ansel Adams’ Zone System for still photography. Ozone allows you to manipulate the color of an image with incredible flexibility and accuracy using a Digital Zone System. The Digital Zone System takes the spectrum of image values and divides them into 11 discrete zones. The color, brightness, contrast and gamma of each zone can be independently adjusted until you’ve painted a new picture.

The $50 program is available as a “demo“.

See also Light 3.5 and Power Stroke 1.0 from Digital Film Tools.

Share This