This post contains a Sublime Text 2 custom build package that lets you run ExtendScript code targeting Adobe Photoshop. I’ve coded it applying few tweaks and customization to an existing package made by Sébastien Lavoie for After Effects scripting. 

What is that for?

When you code Photoshop scripting, chances are that you do it with the ExtendScript ToolKit (aka ESTK). While this Adobe provided piece of software has some unique features that make it very efficient while debugging and looking for DOM documentation, as an editor it really sucks. I’m sorry about that, but compared to other modern editors it’s barely usable.

Sublime Text 2, conversely, is an amazing editor with tons of features and plugins. Yet so far the only workflow for Photoshop scripters was to code ExtendScript (which is a superset of Javascript) in Sublime Text, then copy and paste it to ESTK and run the script from ESTK.

This custom build package lets you run ExtendScript code targeting Photoshop in Sublime Text 2. Type ⌘B (or ctrl+B) and your code is being executed in the host app!

Installation

Download ExtendScript-PS, the Sublime Text 2 build package for Photoshop ExtendScript. Unzip it and move the ExtendScript-PS folder in:

[OSX] ~/Library/Application Support/Sublime Text 2/Packages

[Win] ~\AppData\Roaming\Sublime Text 2\Packages

If you’re unsure where the Packages are located on your system, find them from the Sublime Text menu: Preferences – Browse Packages… Do an app restart, just in case!

How to use it

Write your ExtendScript as usual, and save the JSX file you’re working on.

Make sure the Tools – Build System – ExtendScript_PS is checked, then build the script with ⌘B (Mac), ctrl+B (PC) or the Tools – Build menu item.

As you build it, the JSX script is copied to the Photoshop’s Presets/Scripts/ folder, (a confirmation message appears on the Sublime Text 2 console), then it’s run in the host application.

Depending on your platform and/or PS version, a couple of tweaks may be needed in order to make the it run in your system: please open the ExtendScript-PS folder (in the Sublime Text 2 packages) and read along.

Mac Hacks

The build package, as it is, works on Photoshop CS6. Check that the build.sh file contains information that matches your system in these lines:

# Your CS version
version="CS6";

# Adobe Photoshop folder location
base_path="Applications";

# Full path
full_path="/${base_path}/Adobe Photoshop ${version}/Presets/Scripts";

Particularly, set the correct:

• Photoshop version (CS5, CS6…) which has to match the application’s folder name.
• Photoshop paths – application and Scripts – in case the localized string is something different from \Presets\Scripts\

In the script.scpt file make sure above mentioned information are correct too (version, paths):

on run arg

  set fileName to arg's item 1
  set psVersion to "CS6"
  set basePath to "Applications"
  set theFile to POSIX path of (basePath & ":Adobe Photoshop " & psVersion & ":Presets:Scripts:" & fileName)

  open for access theFile
  set fileContents to (read theFile)
  close access theFile

  tell application "Adobe Photoshop CS6"
    do javascript fileContents (* show debugger before running / never / on runtime error *)
    activate
  end tell

end run

Moreover (see line 14) you can uncomment show debugger to activate ExtendScript Toolkit: available options are either before running, never, on runtime error.

Windows Hacks

The build package, as it is, works on Photoshop CS6 (64 bit). I’ve tested it on a virtualized Windows 7, so feedback from actual PC users is welcome. Check that the build.bat file contains information that matches your system in these lines:

:: Change this accordingly to your CS version
set version=CS6

:: Adobe Photoshop folder location 64 bit versions:
set ps_folder_path=c:\Program Files\Adobe\Adobe Photoshop %version% (64 Bit)

:: Adobe Photoshop folder location 32 bit versions:
:: set ps_folder_path=c:\Program Files (x86)\Adobe\Adobe Photoshop %version%

set ps_scripts_folder_path=%ps_folder_path%\Presets\Scripts

Particularly, set the correct:

• Photoshop version (CS5, CS6…) which has to match the application’s folder name.
• Photoshop folder (in the comments there’s the default 32 bit path if you need it) – change it accordingly if PS has been installed in a custom disk/directory.
• Photoshop Scripts folder – in case the localized path is something different from \Presets\Scripts\

Credits

I’ve cloned from GitHub the original Adobe After Effects package for Sublime Text 2 made by Sébastien Lavoie - which I have tweaked to fit Photoshop’s scripting needs.

I’m a poor hacker, so if the package doesn’t work properly it’s my fault only. Feedback is welcome as usual, happy coding!

This post will describe how to setup a local Git repository, sync it with a private DropBox repository for cloud backup (as it were a GitHub hosted one) and use the Sublime Text Git plugin to manage it.

Get ready with Git

Download the latest Git version from the official website. To date, the latest package available is called git-1.8.2.1-intel-universal-snow-leopard.dmg (I’m running it successfully on OSX 10.8.3 Mountain Lion). Launch the installer, and when it’s done open the Terminal (Applications/Utilities/Terminal.app) and type which git

This is what I got, meaning that the path for the git executable is /usr/local/bin/git (or whatever it is on your machine) which is something you’ve to remember.

If you want (I do), you can download as well a GUI Client – providing you with a nice graphic interface. There are plenty of them, I’ll stick with the free original GitHub app for the Mac.

Depending on your skills (I’m not a very seasoned Git user, to put it mildly) and preferences, you’ll be able to drive your version control system either via command-line and/or visually through the GitHub app.

Get ready with Sublime Text

Sublime Text is a really powerful text editor (TextMate is another one I’d suggest): among the plethora of available plugins, install the free Sublime Package Control first and you’ll never regret it (installation instruction here). It will help you look for, and install, all the (other) plugins you may ever need.

Then, in Sublime Text do the usual ⌘⇧P to open the Command Palette and start typing “install” – as you type, the actual command will appear, which is Package Control: Install Package. Then look for Git and Enter to install it – visit also at the plugin official page for more information.

So far so good – yet the Git plugin isn’t working yet because Sublime Text needs to know the Git’s path (the one you’ve found before). Open with a text editor of your choice (guess which one!) the file called Git.sublime-settings found here:

/Users/<yourUser>/Library/Application Support/Sublime Text 2/Packages/Git/

And look for the following lines:

// if present, use this command instead of plain "git"
  // e.g. "/Users/kemayo/bin/git" or "C:\bin\git.exe"
  ,"git_command": "/usr/local/git/bin/git"

Of course be careful to type the correct path for the git_command, (recall what was the output of the which git command) then save and close (this issue is covered here).

Set a DropBox “remote” repository

One thing you could do (I did it – but it’s not what I’ll be suggesting) is to create a Local Repository in the Dropbox folder on your HD: here both your files and the repository are backed-up on DropBox servers. Unfortunately, this way you’re forced to keep all your dev stuff within the local DropBox folder – i.e. all your files – and this is not what you want.

As a more efficient alternative, you’ll keep a local repository in your usual development folder, then push it to a DropBox repository as it were a GitHub hosted one.

Let’s assume that your DropBox folder is ~/Dropbox and the folder where you do your development is ~/dev/photoshop. You’re going to work on a job called psProject01. Open the Terminal app.

1. Create the DropBox repo

$ cd /users/Davide/Dropbox
$ mkdir psProject01.git
$ cd psProject01.git
$ git init --bare

You’ve made and initialized a bare psProject01.git repository in the DropBox folder.

2. Create the Dev repo

This is on your usual development folder.

$ cd /users/Davide/dev/photoshop
$ mkdir psProject01
$ cd psProject01
$ git init

As a result, a hidden .git folder is created inside psProject01. Now there are two empty repos, one on the DropBox folder, one on the dev folder.

3. Link the repositories

The following command will link the DropBox repository to the dev one (you’re still in /users/Davide/Dev/photoshop/psProject01)

$ git remote add origin /users/Davide/Dropbox/psProject01.git

Someone is using a different syntax, but apparently the former one works too:

$ git remote add origin file:///users/Davide/Dropbox/psProject01.git

4. Add files to the Dev repo, Commit and Push

For some reason, I haven’t been able to use the Sublime Text Git plugin to Git: Add Current File (i.e. create a new file in Sublime Text and add it to the repo, I get this error: “git branch: fatal: ambituous argument head unknow revision or path not in the working tree”) at least until a first file has been added via command line, the change committed and the repository pushed:

$ touch lib.jsx
$ git add lib.jsx
$ git commit -m "Initial commit, lib.jsx added"
$ git push origin master
  Counting objects: 3, done.
  Writing objects: 100% (3/3), 225 bytes, done.
  Total 3 (delta 0), reused 0 (delta 0)
  To /Users/Davide/Dropbox/repo.git
  * [new branch] master -> master

The above creates a lib.jsx file and adds it to the dev repository. Then the change is committed, and the repo is pushed to the DropBox “remote” repository (which is on the HD, but it’s the same command you’d write for an actual remotely hosted repo).

Mind you, if you look into the /users/Davide/Dropbox/psProject01.git folder you won’t see any lib.jsx file: the Dropbox repository only contains the Git’s guts. If you want to double-check that everything went fine (and the file is actually stored in the Git database), you can clone the repo to a different location, for instance:

$ cd /users/Davide/dev/
$ git clone /users/Davide/Dropbox/psProject01.git testRepository
  Cloning into 'testRepository'...
  done.

Now if you inspect the /users/Davide/dev/testRepository folder you’ll find the lib.jsx file there! Does it make sense? Articles I’ve used as a reference for these commands are found here and here.

Using Sublime Text Git plugin

Now start doing something with your newly created lib.jsx file, like:

// Test file
#target photoshop

alert("Hello World");

and save.

Commit

You can commit with ⌘⇧P to open the Command Palette and then typing Git: Quick Commit:

Then enter a short description:

And the following is the correct output:

Log and Diff

⌘⇧P and then Git: Log Current File shows you the commit history:

Choosing one item shows you the details:

Push

⌘⇧P and then Git: Push Current Branch:

A list of supported commands is found in the Sublime Text Git plugin page.

Using the GitHub app

If you feel more comfortable with a graphic user interface, start the GitHub application you’ve downloaded before and add a Local Repository (pointing to the dev folder) with the little plus button in the bottom bar:

Double click on the psProject repository to see the History list:

And eventually double click on a single item to view the commit’s details:

From the app you can Publish/Sync the branch, add new files, etc – the very same things Git command line allows you. I’m still finding my way around all the options, so as a very basic user I won’t suggest you anything but the initial setup.

Caveat

True, DropBox sync may let you run into troubles if you and someone else are pushing stuff at the very same time, but as a single developer this won’t be a problem. Be aware, just in case you use DropBox to share your Git repository to others.

It’s now available through Adobe Exchange my latest, and most minimal so far, free extension for Photoshop called Theme Switcher. It simply lets you pick up the GUI Theme (that is: the Photoshop interface color, which since CS6 goes from Original to Light Gray, Medium Gray and Dark Gray) with one click – handy little panel that eliminates the need to dig into the Preferences.

Please find the Exchange page here and the product page on my commercial website CS-Extensions. If you happen to like it, please leave a review or some stars along your way!

Color Correction Maestro Dan Margulis has just published a new book about his latest research, titled “Modern Photoshop Color Workflow – The Quartertone Quandary, the PPW, and Other Ideas for Speedy Image Enhancement”.

Waiting for it to be shipped in my country too (it’s for sale on Amazon.com priced for a limited time 64.95 USD, and with a well deserved average customer review rating of 5 stars) I’ve asked to three beta-readers, who happens to be among my best friends and experienced colleagues, few questions about the book’s topics. Read along, I’ve a special guest too!

The Book

As it is in his style – and this one is no exception – Dan’s books have two apparently conflicting characteristics:

1. They’re somehow timeless: Dan teaches concepts first, then he elaborates the techniques exploiting them.
2. They’re deeply rooted in the years they’re published in: for instance, if early books were mostly CMYK oriented, a mixed approach has been adopted lately, when the consumer digital devices market changed the business.

So to speak, the times, they are a-changing… and Modern Photoshop Color Workflow shows their evolution – targeting professionals’ need of impressive results in a fraction of the time (which equals a fraction of the money) that was the norm in the past. The fact that, in order to learn speed, you’ve got to go through 450 pages of dense writing should suggest that the theory is quite structured. Nevertheless, the effort is well rewarded.

The book website is now online, with tons of free learning resources such as videos and articles. Dan’s driven the development of a dedicated Photoshop PPW panel (Picture Postcard Workflow) too, which is available for free, that multiply your control over the workflow and makes it even more powerful.

The Beta-Readers

Dan’s been using beta-readers – i.e. a small group, about ten people strong, which is asked to read and comment the book as the author writes (and possibly re-write) it. Among the people who volunteered from all over the world, four italians were deeply involved in the project:

• Giuliana Abbiati [codename: GA, PPW panel software architect]. Creative mind, Photoshop extensions coder.
• Alessandro Bernardi [codename: AB, beta-reader] Professional retoucher/colorist, founder of the PS-School project, which manages Dan Margulis classes in Italy.
• Daniele Di Stanio [codename: DDS, coordinator]. Professional teacher and founder of Albero del Colore, a unique web-based learning experience of comparative color correction challenges.
• Marco Olivotto [codename: MO, beta-reader]. Professional teacher and founder of the Color Correction Campus project, ACT-like classes in Italy.

Interviews

Due to work commitments she’s been engaged into, Giuliana couldn’t join the interview – but I plan to ask her questions on a dedicated blogpost when she’ll be back.

PPW Evolution

DB: I’ve bought my first Margulis’ “Professional Photoshop” book in the year 2000 and I’ve followed him ever since, so I’ve a pretty decent grasp on how much, and in which direction, Dan’s techniques have evolved over time. To my eyes, it looks like this latest workflow marks both a discontinuity from the past and makes a good point being “fit” – if I may use this darwinian terminology – in our times: that’s probably because the image business, and as a consequence our jobs, have changed dramatically in few years. Could you tell us how Dan has shaped, refined, and systematized it since you’ve heard about it first?

AB: Well, you’d surprised, but I often use a gastronomic example to explain the PPW because it’s like cooking a good recipe. Let’s say that you want to prepare a simple dish like “pasta alla carbonara”. Usually you start with very basic steps. The first ones are very important and will decide the success of your final dish. I mean that if you put the olive oil and then you burn too much the bacon, then your pasta will be too much “alla carbonara” and won’t be good. But also the middle steps are very important and so on.

We have learned in Dan’s classes, many “cooking” techniques, but when you have to correct an image, that is the moment in which you have to take some decisions. You must decide how much contrast, how much color or sharpening you want to add to an image, and the way you cook and mix all these ingredients can lead to a success or a failure.

Here comes the first key word: the workflow. My first impact with the Picture Postcard Workflow was in November 2007, in Dan’s Advanced class in Toronto. I had already attended his regular class in March, and Dan had presented the PPW in his first shape at Photoshop World one month later, in April. So, we were the first group of students that had the opportunity to test the workflow during the class. I was prepared to learn many new techniques, but when Dan showed the PPW in its first version, I was surprised to see how quickly he took all the critical decisions about luminosity and color that produced a good image in few minutes.

The secret behind was the workflow: he had summarized all his knowledge and techniques in an effective workflow to allow good results in a matter of minutes. We began to experiment with the first PPW and the final results were pretty good, compared to the traditional workflows.

The idea of splitting all the steps in three main ones (eliminating the color problems, optimizing luminosity and contrast, boosting colors) is simple, and simple ideas work in almost all cases. Once you have solved color issues, think of how liberating is to work on luminosity and contrast. You can concentrate only on that and decide better how to optimize them. And then the final touch, the color boost. And it was only the beginning.

On my personal side I had the opportunity to see how the PPW evolved during the years as I have arranged all Dan’s classes here in Italy from 2009. So I’ve seen how it was introduced in his regular classes and how was taught in the advanced ones as well. In 2009 the workflow was already improved and some steps were revised to improve both speed and quality. After only one year, in 2010, we recorded what is currently the most complete video resource about the PPW. While we were taping I saw that the workflow was improved again, introducing some actions to speed up steps like the Color Boost and the Sharpening. After that came one of the most important additions: the Man from Mars technique became “Modern” as it was done through a simple action that required a rough selection to guide Photoshop for introducing color variation.

Then the Skin Desaturation action was added to pre-desaturate images featuring faces and Dan’s attention moved on other aspects like the False Profile and, later, the Hemholtz Kohlrausch effect.

This leads to the second key word: evolution. Thanks to Dan’s luminous mind and experimentation, and to the students’ feedbacks, the workflow was evolving. At that point was clear that having all these cooking, er, enhancing techniques inside the workflow required a better kind of automation. Dan had already started to work on a panel to put together all the actions. But I’m proud to say that it was during his first Italian advanced class, that what we call now the “PPW Team” came into the light.

Giuliana Abbiati was involved in programming a PPW panel and we worked hardly on the layout to build a flexible and comfortable tool that could speed up the entire workflow and make it more reliable. We decided to put all the documentation written by Dan inside the panel and put also some additional articles written by me and one of the best Italian color correction teachers, aka Marco Olivotto. And even the panel had evolved, thanks to Giuliana’s constant efforts. She introduced scripting through which the panel can intelligently recognize the color profile of your image when you apply the false Profile technique, not to talk about the options that expand the possibilities of the Bigger Hammer, Modern Man from Mars, Color Boost and Sharpening actions. Now I would say that the PPW would not be the same without this panel, but the panel won’t be as it is without Dan’s improvements to the workflow.

And what about the workflow itself? I would say that in six years the key points are still the same (three main steps) but we have more options for specific cases and the speed has been improved around 40%, not to talk about the flexibility. This fits much better the current market’s needing, that is speed, quality and reliable results. Dan’s current approach has changed accordingly, moving from spending a lot of time on a single correction, to making different versions of the same image in the same amount of time, and blend their best part together.

This was not possible in 2007 when PPW was born, as all the techniques had to be made by hand. But now, with the power of automation and a fully tested workflow, it’s feasible and can give impressive, though unpredicted, results.

Teaching the Workflow

DB: Color correction has always implied a broad knowledge of principles and techniques, which experience reinforces. Yet, if you see Dan working with the PPW panel, it looks like a fast and apparently effortless process. Since you’ve been teaching the PPW in your own advanced classes, what are the pitfalls from the educator’s point of view? How have you managed to pass the workflow’s concepts to your students effectively?

MO: Short reply: I hope my efforts were effective, but I must say it’s not as easy as it may seem.

More in detail, I’ve had three different approaches: a rather formal one, in a video-course, where techniques must be made very clear to a potentially dishomogeneous audience; a rather “idealistic” one, in the class, where I may easily see if people are following or not, but usally attempt to deliver the philosophy of the workflow rather than every detail of the technique; finally, an informal approach, in workshops, where I have two to four hours to explain what the whole thing is about and show some examples.

Let me start from the bottom, i.e. workshops. The first time I attempted to explain the PPW in such a situation I failed flat. It was my fault – I had 90 minutes and that wasn’t even enough to scratch the surface. Moreover, it was at an exhibition, and these are known for utter chaos and a necessity to be quick and entertaining. I later discovered that I could throw together some decent ideas in a couple of hours, and finally settled on the fact that four hours are enough to cover the workflow in detail. What level of detail strictly depends on who is listening, though. In classes it’s easier: the people who attend already know the basics of color correction and can therefore can grasp ideas quickly. To me, the core of the PPW is perception: I try to always keep that light on when I explain things, because less experienced practitioners may think that the Helmholtz-Kohlrausch effect is a commodity rather than something intrinsic to our vision. All in all, the feedback has been good, so far. Finally, video-course: nobody ever complained, and the approach was not to do a set of images from start to finish, individually, but go through four images together, side by side and step by step. I thought that this approach might easily show when something is needed and when something is not needed at all.

It must also be said that the PPW is highly volatile and somewhat dangerous, in general. It is a short workflow, but it takes time to see through it. I recently launched a small contest on facebook, and about 30 different versions of the same picture arrived. I think at least 15 of them, maybe more, either went through the PPW or something which seriously attempted to mime it. My own version, done in about five minutes, was better than most but definitely worse than at least two made by students of mine. The basic difference was that they cobbled together a way to get better luminosity than mine, and there was no discussion in the end: their approach was better. In this sense, PPW is very democratic: if someone finds a way to correctly enhance an important aspect of the picture and others won’t, his chances of winning in a comparison go skyrocketing.

The PPW from the user’s POV

DB: The book thoroughly describes each step of a workflow that can branches into several sub-strategies, and Dan’s worked hard to systematize the PPW up to a great extent. What is, in your opinion, the degree of freedom that a retoucher using the PPW has? Color correction challenges you’re leading on your website expose you to a large amount of versions of the same image made by different operators; from this peculiar position, what are as a teacher your suggestions to really master the PPW?

DDS: Ciao Davide, and many greetings to your reader, it is a pleasure for me to be a guest in not-another-news-blog, but a website that goes in-depth and try to analyze what is around us. My experience as a color correction teacher is telling me that we have a big issue here.

Let me explain, first, that the word “freedom” that is a good word in every professional field is not something you can easily use in same sentence with “workflow“. A workflow, is a series of steps that we code to avoid over-thinking, to cut out mistakes or just to save time. So how can we have a workflow that grants us freedom? The answer is surprisingly easy, and as a teacher I’m just delighted Dan chose this way. The PPW entrusts the user to make the right calls, at the right time, on the right images. Of course we can now see, also, the major drawback. Uneducated users will produce poor results. Also we should split our professional field in two areas, users who already know Margulis methods, and all others. Let’s not be worried with the first, let’s focus on the latter category.

Our world is ruled by usually wrong ideas about Photoshop, and how to use it. But we need to be fair and understand that 100% users today starts learning it on web. Youtube videos, text and images tutorials. But teaching is a complicated matter, so large efforts are wasted on explain tools buttons, and showing where these tools are. But (at first) users grow their Photoshop culture like this, someone tells them where tools are, how to use it and what they do. But no one is telling me when they should use these or on what images (or why). And let’s not be mistaken, even this is already a huge effort for users, many of which are (for example) photographers that should be outside shooting.

Now imagine what happens when these users meet the PPW. At first they are lost. They are overwhelmed by possibilities, by the numbers of tools. Also, we’re talking about new users who are not so strong in image evaluation, so they will probably fail in choosing the correct approach many times. But this, this right here, is where the PPW really shines. And this is the reason why I think that Mr. Margulis invented something that no one ever did in the technique history.

This is not (in my humble opinion) a workflow. This is a workflow’s framework. Dan built a subset of tools and instruments, and arranged them in a “progressive” way. All of this, more, is built on a software like Photoshop, that allows professional to work with degrees of freedom you can’t find anywhere else. Extremely beautiful, and very dangerous. I spent several months researching about how to teach the PPW. Not an easy matter, but I found just the best recipe. And it was so simple, I’m now feeling really stupid. Me and you, Davide, had the chance in seeing Dan start teaching PPW, it was 2009, and it was a stripped down version, it was the foundation of what it is today. Then we saw Dan adding tools, and refining procedures, and let me say we also saw Dan adapting everything to the latests technologies. I will start recording my videos that teaches PPW in the coming weeks, and my approach, the only sensible to me as of now (please note I’m talking about teaching to students that never heard about PPW) is to split my lessons in three categories, where in the first you get the core training, few essentials procedures. And built on top of that in the following two sessions, adding tools, degrees of freedom, choices and mistakes. And you can see my answer is complex like PPW, a workflow, well to me a workflow’s framework, that will allow each and every professional to adapt it to their own work, not the opposite we see every day.

New Frontiers

Dan’s been putting great effort constantly fine-tuning the workflow, and the Modern Color Workflow book will probably become a new standard in the field. Where do you think color correction research should point to, now? What’s the topic that interests you the most, given the PPW as the starting point?

AB: This kind of question is always difficult to answer as we don’t know how the market will evolve in the next years, and how fast. From my point of view I see two main areas in which I’ll try to invest my time and experimentation on color correction.

The first comes from my current specific field (retouch for advertising and fashion) and is creative color. What I think is one of the biggest Dan’s teachings is the way of controling images through the numbers, beyond the thought that is behind his techniques.

The advantage of having a full workflow like the PPW with so many automated steps, gives me the chance to experiment with only one or few steps to get creative results. For example, using the Bigger Hammer without doing it manually, can lead to some unconventional results on portraits. And with so many options available in the panel, I can concentrate on the final result and do my experiments very quickly.

Or, instead, think about the MMM action. We normally uses it to introduce color variation and make images more pleasant. But if you know how to use it, you can try the MMM on some “finished” images intentionally to introduce color shifts. This kind of results can be suitable for the creative market in which conventional colors are sacrificed in favor of the client’s personal taste to have particular color looks. Is what I call “Creative MMM” and thanks to Dan, we have now a dedicated video on the book’s website.

The second area is one in which I’m currently investing the biggest amount of time: color correction for video. Now that Photoshop allows to manage decently video files, I can use some of Dan’s techniques for correcting colors in videos. It’s not so easy to realize and you must find some workarounds to make them suitable for videos, but it can produce stunning results. Enhancing a video through the use of channels, or some adjustment layers in combination with blending modes and smart filters is amazing and fascinating at the same time. And the nice thing is that you can integrate the possibilities offered by the PPW in Photoshop with the typical editing softwares like Adobe Premiere and After Effects.

That’s why I think that the key word in the next years will be “integration”. Who knows, maybe in the near future we’ll be able to have a version of the PPW suitable for videos with a panel like the current one that could be switched to video mode.

But without Dan’s techniques this could have never been possible to me. And, definitely, this is the most important key point.

DDS: You’re not going to like my answer. I think our major shift in these last years, is that we’re struggling to understand exactly how our images are built or composed.

The hardware’s processes are a bit out of hands, and RAW processors are forcing us to steep learning curve. We can say that our world is getting quite complicate out of Photoshop, something I think we were not needing. I sometimes ask myself if there is more to research on color correction, not an answer I found, yet. Studying with Dan shifted many things, I started researching on perception, for example. But I also found out that many times what we need is not really something entirely new, but to be able to define, or to find a name, for something already exists.

As a collective I think the best way to move forward is to take several steps backwards. To drop for good the “tutorial” way, if it is not carefully inserted in a honest context. To stop believing everyone can be a teacher.

We’re blessed to live an era where Masters are still here, and still working for us, with us. I foresee the real direction for PPW, though, will not be pursued as a collective, but as singles. We have all the tools, and we have the chance to make those ours. As teachers the real challenge we’re up to is to successfully teach PPW. Something that happens, to me, not when the user understood all steps and is able to repeat those, but when feels confident in changing, experimenting and move the PPW forward to new directions. Thank you Davide. And many thanks to Dan Margulis that is, and will always be, my Maestro.

MO: I think I understand about the future of color correction as much as I understand about women; that is, next to nothing.

Seriously? The push is towards a fast workflow: with few notable exceptions, the time when one could spend 30 or 40 minutes per image are gone. Entire fields of photography rely on software like Lightroom, which is fine, but it has no layers, which makes it a completely different universe from the one I am used to live in. Add to it that some visible personalities are seemingly preaching that the only button missing in ACR is a large red thing labeled “PRINT!!!”, and you have the raw picture (sorry for the pun). I wonder if they ever realized how ridiculously bad the ACR preview can be (question: can one really sharpen in ACR? evaluate banding? subtle color changes?), but that’s it.

A few things I’d love to see in Photoshop could possibly jeopardize some of the steps in the PPW, but I guess the PPW is more a philosophy than a settled bunch of advanced techniques: the proof of this is that some (possible) steps were almost completely erased, like Multiply in Lab (which I liked a lot, by the way). Overlay in Lab is off, Man from Mars has evolved in a totally different direction than the original… so, who can say where it may go?

I can tell you what I would love to see in Photoshop CS-whatever, with whatever > 6, but I think this is going to remain a dream:

• Better blurring algorithms, able to catch the borders of an object without being as clumsy as Surface Blur.
• A revamped approach towards Unsharp Mask.
• The ability to actually edit whatever color profile, 3D LUT’s included.
• Better tools for local contrast: there is a huge literature out there, and seemingly someone is inventing something new everyday, but these tools never seem to get in the right place (but they may appear in ACR – guess why?)
• Better demosaicing algorithms in ACR.
• Some serious noise reduction.

As far as I am concerned, 3D and the Timeline are more than enough as they are, thank you. When I think of the possibility that in the next release someone may decide to add the opportunity to uhm, hey!, edit CSS natively in Photoshop, my gut reaction is to play “Radio Clash” at outrageously loud volume, and cry like a baby at the immortal verse: “Please save US, not the whales!”

A Very Special Guest

I’ve reached Dan Margulis few days before the book pressrun, and he’s been so kind (which is not a surprise at all) to answer my question too. Codename: DM.

DB: Over the years the techniques you’ve been advocating have evolved, because the (shared) knowledge in the color correction field has progressed. What looks bizarre to my eyes is that the PPW, as the latest application of a constantly advancing theory, makes use of tools (False profiles, Lab, masks, blending modes, etc.) that were available since Photoshop CS, i.e. 10 years ago. Of course we now use them in a modern way. Technologically speaking, the only real new, distinctive PPW tool (that fully exploit its power) is the panel – that is a tool that somehow you’ve built yourself – with Giuliana’s help. That’s paradoxical in my opinion. Image processing technology has evolved too, and at a high pace – but somehow these two lines didn’t cross too much (or not at all? May one provocatively state that Color Correction has progressed in spite of, and not thanks to, technology?). How is it, in your opinion – if you agree to some extent with the above? What should we look at now, as a generation of people willing to contribute to the evolution of the applied color theory?

DM: One can provocatively state that Berlusconi should be the next pope, or whatever else one likes. However, both propositions are equally invalid.

It’s true that Photoshop has stagnated. The development of hardware has not, and that has made all the difference. I don’t have the price lists for 10 and 15 years ago, but for the book I looked at 18 years ago. At that time, RAM was 5.000 times as expensive as today. This was a bargain compared to hard disks, which were 10,000 times as expensive. I can’t figure out the difference in computing speed, but it’s at least 500x and maybe 1000x.

Something like the PPW sharpening action couldn’t possibly have run under these circumstances. First, we would not have the scratch space it requires, and second it would take an hour or so to sharpen a single image.

Similarly, the signature move of the PPW, the MMM action, makes use of a command that nobody has heard of, Equalize. People haven’t heard of even though it has existed for more than 20 years, because in the early 1990s experts like myself dismissed it as useless. And we were right–it was useless at that time, because to get any benefit requires a complicated procedure that would have brought computers of that time to their knees.

But probably the major impact of technology is communications. Without google, and without the means of transmitting large pictures cheaply, the development of knowledge is deterred because people interested in the subject can’t find and share information conveniently. My last three books were immeasurably better than anything previously because they were supported by international groups of beta readers. It wasn’t possible ten years ago, and my earlier books were published with many misconceptions for want of adequate feedback.

You yourself represent the new order. Your ideas are out there for people to look at, discuss, and improve. It’s easier than ever for users to reject vendor hype and find their own best solutions. So I expect that the field will continue to evolve rapidly, and I hope you will be one of the big reasons!

[Thank so much to all the friends that made this possible! Dan's picture is © J.Scarponi]

I’m not a FX kind of guy, but as a developer I’m fascinated by the astonishing complex results you can get with simple Gradients and a Parametric Curves in Photoshop. These designs can be used as building blocks for all kind of creative needs – whether bump maps, depth maps or displacement maps, abstract design, patterns, etc.

Parametric Curves

I’ve started playing with the idea of drawing mathematically defined Curves via scripting. That is, not you adding/dragging points on a Curves window; but let ExtendScript code fetch user inputted formulas and draw the Curves accordingly. Let’s say it could be a prototype test for a future Photoshop panel.

So I’ve coded a simple script and, after a good dose of trial and error, I came up with some pretty interesting shapes:

Curves (as Adjustment Layers) I’ve drawn via scripting.

Some of them may be replicable by hand (with a good dose of patience), others can be built via scripting only. These kind of curves are normally available in Filter Forge, a Photoshop plugin for texture creation I’ve enthusiastically written about here – but are out of reach if you don’t own it.

Gradients

The above Curves have no use on real imaging but forensic and/or scientific ones (maybe – if there’s a forensic expert out there I’m all ears! The comment section is open for you), but if you put them above a Gradient adjustment layer, the fun begins. I’ll be using 16bit files (in order to avoid posterization, some of these transformations are pretty harsh), with all of the available Gradient shapes:

Available gradients in Photoshop: Linear, Reflected, Radial, Diamond, Angle

Gradient + Curves

Let’s start experimenting with a mix of Curves and Gradients. Be aware that you can mix multiple Curves and Gradients, and play with Blending modes too!

Linear

Radial

Angle

Reflected

Diamond

Combined gradients

If you start adding multiple Gradients and Curves on top of each other, you may end up with some really interesting results:

It gets addictive when you start must I confess…

What for?

I’m not the creative one, I’m just owning the hardware store providing you with the tools

That said, as the only untalented designer available on duty at the moment, I can show you just few examples to tease your creative skills. These are just building blocks, combining them the possibilities are endless.

Patterns

This is a very simple one, textured and ready to be tiled.

A: Gradient + Curves. B: Perlin noise (Clouds) + Motion Blur. C: Perlin noise + Gaussian Noise. D: Combined result.

Displacement maps

Pretty hidden in the menu, there’s the Distort – Displace filter. It requires you to open a second image (the Displacement Map), to be used to distort the first one according to the parameters you’ve set.

A: Gradient + Curves. B: Texture. C: Texture displaced. D: Combined result.

3D Depth Maps and Bump Maps

Believe me, I rarely open any 3D panel in Photoshop because I’m a 2D chauvinist, so this one is really a basic example that may make the actual experts laugh, but it’s just to give you the idea of using gradient as Depth Maps.

From the Photoshop CS6 menu 3D – New Mesh from Layer – Depth Map to – Plane

Another couple of Depth Map examples

Similarly (but with a subtler effect) you can apply those gradients as actual Bump Maps in 3D materials.

Animations

All kind of weird stuff… this is just an example of what happens if you shift Gradients (on selected channels only) when one or more parametric Curves are applied. Click on the image to launch the video.

Few examples – scripting the gradient interaction would lead to even more interesting results

Parametric Curves on Exchange!

Parametric Curves is available as a free script for Photoshop CS6 (Mac/Win) through Adobe Exchange – the new in-app, app-store panel made by Adobe itself. Download and install Exchange if you don’t already have it, then browse the Free extensions and look for Parametric Curves there. After the installation, please find it in the Filter menu. More info about the panel here.

ScriptUI windows can contain several controls (checkboxes, sliders, etc), and to setup a Preset system is a very handy way to allow users save and retrieve their own preferred configurations easily. In this tutorial I’ll show you how to implement Presets with a DropDownList menu based upon XML data.

Starting point

I’ve set up a simple demo dialog using a resource string – you can use it either in InDesign or Photoshop for instance: this is the base which I’ll be using throughout the post adding functional bits of code. (I’ve used CoffeeScript, a nice language that compiles to JavaScript, to write the whole script; in this tutorial I’m going to show the JS only, but you can find the entire CoffeScript code at the bottom of the page if you’re curious).

#target photoshop;

var win, windowResource;

windowResource = "dialog {  \
    orientation: 'column', \
    alignChildren: ['fill', 'top'],  \
    size:[410, 210], \
    text: 'XML DropDownList Presets demo - www.davidebarranca.com',  \
    margins:15, \
    \
    controlsPanel: Panel { \
        orientation: 'column', \
        alignChildren:'right', \
        margins:15, \
        text: 'Controls', \
        controlsGroup: Group {  \
        orientation: 'row', \
        alignChildren:'center', \
        st: StaticText { text: 'Amount:' }, \
        mySlider: Slider { minvalue:0, maxvalue:500, value:300, size:[220,20] }, \
        myText: EditText { text:'300', characters:5, justify:'left'} \
        } \
    }, \
    presetsPanel: Panel { \
        orientation: 'row', \
        alignChildren: 'center', \
        text: 'Presets', \
        margins: 14, \
        presetList: DropDownList {preferredSize: [163,20] }, \
        saveNewPreset: Button { text: 'New', preferredSize: [44,24]}, \
        deletePreset: Button { text: 'Remove', preferredSize: [60,24]}, \
        resetPresets: Button { text: 'Reset', preferredSize: [50,24]} \
    }, \
    buttonsGroup: Group{\
        alignChildren: 'bottom',\
        cancelButton: Button { text: 'Cancel', properties:{name:'cancel'},size: [60,24], alignment:['right', 'center'] }, \
        applyButton: Button { text: 'Apply', properties:{name:'apply'}, size: [100,24], alignment:['right', 'center'] }, \
        }\
    }";

win = new Window(windowResource);
// binds mySlider.value with myText.text
win.controlsPanel.controlsGroup.myText.onChange = function() {
  this.parent.mySlider.value = Number(this.text);
};
win.controlsPanel.controlsGroup.mySlider.onChange = function() { 
  this.parent.myText.text = Math.ceil(this.value); }; win.show(); 

This scheme lets you:

• Save new custom presets.
• Delete custom presets.
• Reset to the default group of presets (which are protected and cannot be deleted).

The presets are stored as XML data in a file (in the example there’s a single value only, but they can be as many as you need)

<presets>
  <preset default="true">
    <name>select...</name>
    <value/>
  </preset>
  <preset default="true">
    <name>Default value</name>
    <value>100</value>
  </preset>
  <preset default="true">
    <name>Low value</name>
    <value>10</value>
  </preset>
  <preset default="true">
    <name>High value</name>
    <value>400</value>
  </preset>
</presets>

The default="true" attribute marks this presets as read-only (i.e. the user can’t delete them)

Logic

This is how I’ve decomposed the problem (click to open a bigger version)

Building the Presets system

Basically the core is an initialization routine that reads XML data from an XML file (or creates a default one if it’s missing) and fills the DropDownList (DDL from now on) with labels, so let’s start with it.

1. Initialization routine

I’ve set few globals that will be useful for other functions too – the code is commented so it should be quite self-explanatory.

// the XML object holding the XML data
var xmlData = null;

// the array holding the preset labels, used later on 
// to check for label duplicates when adding a new preset
var presetNamesArray = [];

// the preset file (which lives alongside this script)
resPath = File($.fileName).parent;
var presetFile = new File("" + resPath + "/presets.xml");

// Initialization routine
var initDDL = function() {
  var i, nameListLength;

  if (!presetFile.exists) {
    createDefaultXML();
    // recursive call, needed to read and fill the DDL
    initDDL(); 
  }

  // retrieves XML Data
  xmlData = readXML();
  // empties the DDL before adding new content
  if (win.presetsPanel.presetList.items.length !== 0) {
    win.presetsPanel.presetList.removeAll();
  }

  // the number of preset labels
  nameListLength = xmlData.preset.name.length();
  presetNamesArray.length = 0;

  // for each preset XML element, retrieve the <name> label
  // and write it in the Labels array, then add it to the DDL
  i = 0;
  while (i < nameListLength) {
    presetNamesArray.push(xmlData.preset.name[i].toString());
    win.presetsPanel.presetList.add("item", xmlData.preset.name[i]);
    i++;
  }

  // set as the default the first preset
  // which is the placeholder "select..."
  win.presetsPanel.presetList.selection = win.presetsPanel.presetList.items[0];
  return true;
};

As you’ve seen I’ve mentioned some utility functions like readXML() and writeXML(), alongside createDefaultXML(), here they are:

// holds the XML object containing the 
// Default set of Presets
var defaultXML = <presets>
		   <preset default="true">
		   <name>select...</name>
		   <value></value>
	        </preset>
	        <preset default="true">
		   <name>Default value</name>
		   <value>100</value>
	        </preset>
	        <preset default="true">
		   <name>Low value</name>
		   <value>10</value>
	        </preset>
	        <preset default="true">
	       	   <name>High value</name>
		   <value>400</value>
                </preset>
	     </presets>;

// writes an XML object to file
writeXML = function(xml, file) {
  if (file == null) {
    // global, the preset.xml file already declared
    file = presetFile;
  }
  try {
    file.open("w");
    file.write(xml);
    file.close();
  } catch (e) {
    alert("" + e.message + "\nThere are problems writing the XML file!");
  }
  return true;
};

// reads an XML object from a file
readXML = function(file) {
  var content;
  if (file == null) {
    // global, the preset.xml file already declared
    file = presetFile;
  }
  try {
    file.open('r');
    content = file.read();
    file.close();
    return new XML(content);
  } catch (e) {
    alert("" + e.message + "\nThere are problems reading the XML file!");
  }
  return true;
};

// creates a preset.xml file
// using the default set of presets
createDefaultXML = function() {
  // global, the preset.xml file already declared
  if (!presetFile.exists) {
    writeXML(defaultXML);
    return true;
  } else {
    presetFile.remove();
    // recursive call
    createDefaultXML();
  }
  return true;
};

So far the script detects whether a preset.xml file exists: if it doesn’t, it creates a default one – otherwise it reads it and use it to fill the DDL.

2. Save a new preset

I’ve setup the following onClick() function which makes use of createPresetChild(), another utility that grabs values from the GUI and creates a node from them. Which node, in turn, will be appended to the existing XML data.

// used to workaround the lack of indexOf in ExtendScript
var __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

// creates a XML <preset> node 
var createPresetChild = function(name, value) {
  var child;
  // mind you, each custom node has the default attribute
  // set to "false", meaning that it can be deleted
  return child = <preset default="false">
		    <name>{name}</name>
		    <value>{value}</value>
		 </preset>;
};

// onClick handler for the Save New Preset button
win.presetsPanel.saveNewPreset.onClick = function() {
  var child, presetName;

  // ask for a preset name
  presetName = prompt("Give your preset a name!\nYou'll find it in the preset list.", "User Preset", "Save new Preset");
  if (presetName == null) {
    return;
  }

  // in case the name already exists
  if (__indexOf.call(presetNamesArray, presetName) >= 0) {
    alert("Duplicate name!\nPlease find another one.");
    // make a recursive call to this onClick function
    win.presetsPanel.saveNewPreset.onClick.call();
  }

  // creates a <preset> node with values grabbed 
  // from the window controls
  child = createPresetChild(presetName, win.controlsPanel.controlsGroup.myText.text);

  // appends the XML node to the existing XML data (global variable)
  xmlData.appendChild(child);

  // writes the XML object to the preset.xml file
  writeXML(xmlData);

  // you need to initialize again, in order to populate 
  // the DDL with new values
  initDDL();

  // selects the last preset in the DDL
  win.presetsPanel.presetList.selection = win.presetsPanel.presetList.items[win.presetsPanel.presetList.items.length - 1];
};

Please notice the lack of indexOf in ExtendScript (the used __indexOf is courtesy of CoffeeScript)

 3. Delete preset

That’s pretty straightforward, you just need to check whether the default attribute of the preset is false (which means that the preset is not protected and can be deleted). Again, each preset’s modification needs to write the changes to disk in the presets.xml file and re-initialize the DDL in order to populate the menu properly.

// onClick handler for the Delete preset button
win.presetsPanel.deletePreset.onClick = function() {

  // mind you: typeof xmlData.preset[].@default = XML
  // the "!!" is a shorthand for Boolean()
  if (!!xmlData.preset[win.presetsPanel.presetList.selection.index].@default === true) {
    alert("Can't delete \"" + xmlData.preset[win.presetsPanel.presetList.selection.index].name + "\"\nIt's part of the default set of Presets");
    return;
  }

  // ask for confirmation
  if (confirm("Are you sure you want to delete \"" + xmlData.preset[win.presetsPanel.presetList.selection.index].name + "\" preset?\nYou can't undo this.")) {
    // delete the <preset> element
    delete xmlData.preset[win.presetsPanel.presetList.selection.index];
  }

  // as usual, write to disk and initialize again
  writeXML(xmlData);
  return initDDL();
};

 4. Reset presets

Another easy task, just replace presets.xml with a default one (which is hardcoded inside the script).

// onClick handler for the Reset presets button
win.presetsPanel.resetPresets.onClick = function() {
  if (confirm("Warning\nAre you sure you want to reset the Preset list?", true)) {
    createDefaultXML();
    initDDL();
  }
};

 5. Apply preset

The last thing we’ve to add is a handler for the DDL onChange event – that is, the user selects the preset and window controls must be updated with values coming from it.

// DDL onChange handler
win.presetsPanel.presetList.onChange = function() {
  if (this.selection !== null && this.selection.index !== 0) {
    // sets GUI controls
    win.controlsPanel.controlsGroup.myText.text = xmlData.preset[this.selection.index].value;
    win.controlsPanel.controlsGroup.mySlider.value = Number(xmlData.preset[this.selection.index].value);
  }
};

Completed script

Let’s put everything together! As follows both versions (JS and CoffeeScript). Speaking of the latter, XML management in ExtendScript made me use more than I wanted the backticks (which embed regular JS code), but that’s fine – I’m a big fan of CoffeeScript anyway

Javascript

#target photoshop;
var createDefaultXML, createPresetChild, defaultXML, initDDL, presetFile, presetNamesArray, readXML, resPath, win, windowResource, writeXML, xmlData,
  __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };

windowResource = "dialog {  \
    orientation: 'column', \
    alignChildren: ['fill', 'top'],  \
    size:[410, 210], \
    text: 'DropDownList Demo - www.davidebarranca.com',  \
    margins:15, \
    \
    controlsPanel: Panel { \
        orientation: 'column', \
        alignChildren:'right', \
        margins:15, \
        text: 'Controls', \
        controlsGroup: Group {  \
            orientation: 'row', \
            alignChildren:'center', \
            st: StaticText { text: 'Amount:' }, \
            mySlider: Slider { minvalue:0, maxvalue:500, value:300, size:[220,20] }, \
            myText: EditText { text:'300', characters:5, justify:'left'} \
    	} \
    }, \
    presetsPanel: Panel { \
    	orientation: 'row', \
    	alignChildren: 'center', \
    	text: 'Presets', \
    	margins: 14, \
    	presetList: DropDownList {preferredSize: [163,20] }, \
    	saveNewPreset: Button { text: 'New', preferredSize: [44,24]}, \
    	deletePreset: Button { text: 'Remove', preferredSize: [60,24]}, \
    	resetPresets: Button { text: 'Reset', preferredSize: [50,24]} \
    }, \
    buttonsGroup: Group{\
        alignChildren: 'bottom',\
        cancelButton: Button { text: 'Cancel', properties:{name:'cancel'},size: [60,24], alignment:['right', 'center'] }, \
        applyButton: Button { text: 'Apply', properties:{name:'apply'}, size: [100,24], alignment:['right', 'center'] }, \
    }\
}";

win = new Window(windowResource);
xmlData = null;
presetNamesArray = [];
resPath = File($.fileName).parent;
presetFile = new File("" + resPath + "/presets.xml");
defaultXML = <presets>
		<preset default="true">
			<name>select...</name>
			<value></value>
		</preset>
		<preset default="true">
			<name>Default value</name>
			<value>100</value>
		</preset>
		<preset default="true">
			<name>Low value</name>
			<value>10</value>
		</preset>
		<preset default="true">
			<name>High value</name>
			<value>400</value>
		</preset>
	</presets>;

writeXML = function(xml, file) {
  if (file == null) {
    file = presetFile;
  }
  try {
    file.open("w");
    file.write(xml);
    file.close();
  } catch (e) {
    alert("" + e.message + "\nThere are problems writing the XML file!");
  }
  return true;
};

readXML = function(file) {
  var content;
  if (file == null) {
    file = presetFile;
  }
  try {
    file.open('r');
    content = file.read();
    file.close();
    return new XML(content);
  } catch (e) {
    alert("" + e.message + "\nThere are problems reading the XML file!");
  }
  return true;
};

createDefaultXML = function() {
  if (!presetFile.exists) {
    writeXML(defaultXML);
    void 0;
  } else {
    presetFile.remove();
    createDefaultXML();
  }
  return true;
};

createPresetChild = function(name, value) {
  var child;
  return child = <preset default="false">
				<name>{name}</name>
				<value>{value}</value>
			</preset>;
};

initDDL = function() {
  var i, nameListLength;
  if (!presetFile.exists) {
    createDefaultXML();
    initDDL();
  }
  xmlData = readXML();
  if (win.presetsPanel.presetList.items.length !== 0) {
    win.presetsPanel.presetList.removeAll();
  }
  nameListLength = xmlData.preset.name.length();
  presetNamesArray.length = 0;
  i = 0;
  while (i < nameListLength) {
    presetNamesArray.push(xmlData.preset.name[i].toString());
    win.presetsPanel.presetList.add("item", xmlData.preset.name[i]);
    i++;
  }
  win.presetsPanel.presetList.selection = win.presetsPanel.presetList.items[0];
  return true;
};

win.controlsPanel.controlsGroup.myText.onChange = function() {
  return this.parent.mySlider.value = Number(this.text);
};

win.controlsPanel.controlsGroup.mySlider.onChange = function() {
  return this.parent.myText.text = Math.ceil(this.value);
};

win.presetsPanel.presetList.onChange = function() {
  if (this.selection !== null && this.selection.index !== 0) {
    win.controlsPanel.controlsGroup.myText.text = xmlData.preset[this.selection.index].value;
    win.controlsPanel.controlsGroup.mySlider.value = Number(xmlData.preset[this.selection.index].value);
  }
  return true;
};

win.presetsPanel.resetPresets.onClick = function() {
  if (confirm("Warning\nAre you sure you want to reset the Preset list?", true)) {
    createDefaultXML();
    return initDDL();
  }
};

win.presetsPanel.saveNewPreset.onClick = function() {
  var child, presetName;
  presetName = prompt("Give your preset a name!\nYou'll find it in the preset list.", "User Preset", "Save new Preset");
  if (presetName == null) {
    return;
  }
  if (__indexOf.call(presetNamesArray, presetName) >= 0) {
    alert("Duplicate name!\nPlease find another one.");
    win.presetsPanel.saveNewPreset.onClick.call();
  }
  child = createPresetChild(presetName, win.controlsPanel.controlsGroup.myText.text);
  xmlData.appendChild(child);
  writeXML(xmlData);
  initDDL();
  return win.presetsPanel.presetList.selection = win.presetsPanel.presetList.items[win.presetsPanel.presetList.items.length - 1];
};

win.presetsPanel.deletePreset.onClick = function() {
  if (!!xmlData.preset[win.presetsPanel.presetList.selection.index].@default === true) {
    alert("Can't delete \"" + xmlData.preset[win.presetsPanel.presetList.selection.index].name + "\"\nIt's part of the default set of Presets");
    return;
  }
  if (confirm("Are you sure you want to delete \"" + xmlData.preset[win.presetsPanel.presetList.selection.index].name + "\" preset?\nYou can't undo this.")) {
    delete xmlData.preset[win.presetsPanel.presetList.selection.index];
  }
  writeXML(xmlData);
  return initDDL();
};

initDDL();

win.show();

 CoffeeScript

`#target photoshop`

windowResource = "dialog {  \
    orientation: 'column', \
    alignChildren: ['fill', 'top'],  \
    size:[410, 210], \
    text: 'DropDownList Demo - www.davidebarranca.com',  \
    margins:15, \
    \
    controlsPanel: Panel { \
        orientation: 'column', \
        alignChildren:'right', \
        margins:15, \
        text: 'Controls', \
        controlsGroup: Group {  \
            orientation: 'row', \
            alignChildren:'center', \
            st: StaticText { text: 'Amount:' }, \
            mySlider: Slider { minvalue:0, maxvalue:500, value:300, size:[220,20] }, \
            myText: EditText { text:'300', characters:5, justify:'left'} \
    	} \
    }, \
    presetsPanel: Panel { \
    	orientation: 'row', \
    	alignChildren: 'center', \
    	text: 'Presets', \
    	margins: 14, \
    	presetList: DropDownList {preferredSize: [163,20] }, \
    	saveNewPreset: Button { text: 'New', preferredSize: [44,24]}, \
    	deletePreset: Button { text: 'Remove', preferredSize: [60,24]}, \
    	resetPresets: Button { text: 'Reset', preferredSize: [50,24]} \
    }, \
    buttonsGroup: Group{\
        alignChildren: 'bottom',\
        cancelButton: Button { text: 'Cancel', properties:{name:'cancel'},size: [60,24], alignment:['right', 'center'] }, \
        applyButton: Button { text: 'Apply', properties:{name:'apply'}, size: [100,24], alignment:['right', 'center'] }, \
    }\
}";

# Create Dialog
win = new Window windowResource

# globals
xmlData = null
presetNamesArray = []
resPath = File($.fileName).parent
presetFile = new File "#{resPath}/presets.xml"
defaultXML = `<presets>
					<preset default="true">
						<name>select...</name>
						<value></value>
					</preset>
					<preset default="true">
						<name>Default value</name>
						<value>100</value>
					</preset>
					<preset default="true">
						<name>Low value</name>
						<value>10</value>
					</preset>
					<preset default="true">
						<name>High value</name>
						<value>400</value>
					</preset>
				</presets>`

# writes an XML object to a file
writeXML = (xml, file=presetFile) ->
	try
		file.open "w"
		file.write xml
		file.close()
	catch e
		alert "#{e.message}\nThere are problems writing the XML file!"
	true

# reads a file (default=presets.xml) and returns an XML object
readXML = (file=presetFile) ->
	try  
		file.open 'r'
		content = file.read()
		file.close()
		return new XML content
	catch e
		alert "#{e.message}\nThere are problems reading the XML file!"
	true

# creates a Default XML file
createDefaultXML = () ->
	# if file doesn't exist
	if !presetFile.exists 
		writeXML defaultXML
		undefined
	else
		presetFile.remove()
		createDefaultXML()
	true

# creates and returns an XML <preset> element
createPresetChild = (name, value) ->
	child = `<preset default="false">
				<name>{name}</name>
				<value>{value}</value>
			</preset>`

# Initialize DropDownList
initDDL = () ->
	# if file doesn't exist
	if !presetFile.exists
		createDefaultXML()
		initDDL()

	# file exists
	xmlData = readXML() 
	# clean DropDownList
	win.presetsPanel.presetList.removeAll() if win.presetsPanel.presetList.items.length isnt 0
	# how many presets?	 
	nameListLength = xmlData.preset.name.length()
	# empties the names array
	presetNamesArray.length = 0
	# fills the DDL and the presetNamesArray
	i = 0
	while i < nameListLength
		# toString() otherwise its an array of XML objects!
		presetNamesArray.push xmlData.preset.name[i].toString()
		win.presetsPanel.presetList.add "item", xmlData.preset.name[i]
		i++
	win.presetsPanel.presetList.selection = win.presetsPanel.presetList.items[0]
	true

# binds mySlider.value and myText.text
win.controlsPanel.controlsGroup.myText.onChange = () ->
	@parent.mySlider.value = Number @text

# binds mySlider.value and myText.text
win.controlsPanel.controlsGroup.mySlider.onChange = () ->
	@parent.myText.text = Math.ceil @value

win.presetsPanel.presetList.onChange = () ->
	if @selection isnt null and @selection.index isnt 0
		win.controlsPanel.controlsGroup.myText.text = xmlData.preset[@selection.index].value
		win.controlsPanel.controlsGroup.mySlider.value = Number xmlData.preset[@selection.index].value
	true

win.presetsPanel.resetPresets.onClick = () ->
	if confirm "Warning\nAre you sure you want to reset the Preset list?", true
		# remove existing preset file, creates a Default XML file
		createDefaultXML()
		# refresh the DropDownList!
		initDDL()

win.presetsPanel.saveNewPreset.onClick = () ->
	presetName = prompt "Give your preset a name!\nYou'll find it in the preset list.", "User Preset", "Save new Preset"
	if !presetName? then return
	if presetName in presetNamesArray
		alert "Duplicate name!\nPlease find another one."
		# recursion again?!
		win.presetsPanel.saveNewPreset.onClick.call()
	# create a <preset> xml child
	child = createPresetChild presetName, win.controlsPanel.controlsGroup.myText.text
	# append the child to the xmlData
	xmlData.appendChild child
	writeXML xmlData
	# re-initialize the DDL in order to make changes appear
	initDDL()
	# select the last preset
	win.presetsPanel.presetList.selection = win.presetsPanel.presetList.items[win.presetsPanel.presetList.items.length - 1]

win.presetsPanel.deletePreset.onClick = () ->
	# "true" is a string in the XML, not a boolean!
	if `!!xmlData.preset[win.presetsPanel.presetList.selection.index].@default` is true
		alert "Can't delete \"#{xmlData.preset[win.presetsPanel.presetList.selection.index].name}\"\nIt's part of the default set of Presets"
		return
	if confirm "Are you sure you want to delete \"#{xmlData.preset[win.presetsPanel.presetList.selection.index].name}\" preset?\nYou can't undo this."
		`delete xmlData.preset[win.presetsPanel.presetList.selection.index]`
	writeXML xmlData
	# re-initialize the DDL in order to make changes appear
	initDDL()

# Init the DropDownList
initDDL()

# Show the window
win.show()

If you try to open in Photoshop CS6 a 3F (a file with extension .fff, the raw format for Hasselblad and Imacon scanners) coming from the Imacon/Hasselblad FlexColor software, you’re going to run into troubles (but there’s plenty of workarounds!):
That’s because the Adobe Camera Raw (ACR) that ships with CS6 expects the file to belong to a digital camera – which is not. Actually, the 3F is just a plain, bitmap TIFF file with some extra proprietary tags, that ACR can’t manage properly.

This didn’t happen back with CS5, unless you’ve installed some beta version of ACR. Check it out from the menu: Photoshop – About Plug-In – Camera Raw… (CS5 version should be 6.x).

There’s of course a workaround, but first let me review briefly why you do want to open a 3F in Photoshop bypassing ACR.

Why opening a 3F in Photoshop?

In order to retouch it! Think about the 3F as a scanner raw file – you can tweak each parameter in the Hasselblad FlexColor software and finally export a TIFF. Alas, scanned film has to be retouched: dust, scratches, blotches, hairs, chemical halos, you know what I mean. Unless you’re willing to retouch the TIFF each time you export it with different parameters from FlexColor (you aren’t), the best workflow is:

1. Open the 3F in Photoshop CS6 in order to retouch it.
2. Save the retouched 3F.
3. Open the retouched 3F in FlexColor (tweaking the parameters to your taste).
4. Export the (usually) TIFF file from FlexColor.
5. Open the TIFF in Photoshop and let the fun begin.

Why should I export many time a 3F, isn’t one time just enough? Fair question, but consider that:

• People get more experienced over time, and you may want to elaborate a second time a scan you’ve acquired and processed in the past (and you’re not really satisfied with the old result).
• You may want to sandwich two or more FlexColor versions (say, one corrected for the highlights, one for the mid-tones and shadows) in Photoshop.
• You may be a service provider willing to return the client a flawless 3F scan.

So your goal is not to open a 3F with Adobe Camera Raw (which can’t export nor save a 3F), just to open it as a TIFF-like file to retouch it in Photoshop.

1. The easy and smooth way

I’ve discovered this one very recently. Provided you’ve installed the  Imacon 3F Plug-In for Photoshop (see the section 2, below), just File – Open in Photoshop, and select a 3F:

Now, just select the Imacon 3F format as outlined below:

And voilà it will open smoothly and easily!

2. The old tricky way

That’s how I did it before discovering the above method. First thing is the Imacon 3F Plug-In for Photoshop, that you can download for free here. It should be installed by default by FlexColor, so you can check if you have it already. The right place to look into (and/or to copy the downloaded plugin) is the following folder:

[MAC] Photoshop CS6/Plug-ins/File Formats/imacon3f.plugin
[PC] Photoshop CS6/Plug-ins/File Formats/Imacon 3f.8bi

Second thing is to temporarily get rid of Adobe Camera Raw. It’s ACR that intercepts the 3F opening and fires the ”Photoshop cannot open this file” error. You do this by closing Photoshop and moving away the following file:

[MAC] Macintosh HD/Library/Application Support/Adobe/Plug-Ins/CS6/File Formats/Camera Raw.plugin
[PC] Program Files/Common Files/Adobe/Plug-Ins/CS6/File Formats/Camera Raw.8bi

You can move it to the Desktop or some other folder – then restart Photoshop CS6. If you look in the menu Photoshop – About Plug-In there shouldn’t be any mention of Camera Raw anymore.

Now, if you’ve correctly installed the Imacon 3F plugin and got rid of Camera Raw, open a 3F and it should open correctly. Remember to move it back in the correct position when you’re done!

Automatize file moving

If you’re on a Mac (maybe there’s a Windows equivalent, please suggest it in the comments) you can use the OSX built-in Apple Automator application.

Open it and choose File – New – Application. Then, from the Library column select Utilities, then drag the Quit Application in the workspace. There, select the Adobe Photoshop CS6.app from the dropdown menu – just to make sure Photoshop isn’t open when you move files around.

Next, from the Library column select Files & Folders, and drag first the Get Specified Finder Items, then the Move Finder Items components, selecting respectively the camera raw plugin file and the destination folder (the Desktop or a temp folder, for instance).

Now File – Save the application to the Desktop. If you double click on it, the camera raw plugin file moves from its original location to the temp folder. You can build in the very same way an Automator application that moves it back into place. Keep both apps handy, so with a double-click you can move files without having to remember who needs to go where!

Retouching a 3F in Photoshop

If you’re new to 3F, I suggest you to visit the excellent Roberto Bigano’s 3F resources page first. My current workflow, when I’m in need of 3F retouching (which is basically… always), is as follows. Click on the thumbnails for a bigger version.

1. Open the 3F and save a .PSB

Say that you’ve a myScan.fff file. Open it in Photoshop and immediately save a copy as a .psb (Photoshop Large Format document), myScan.psb. Leave alone the original .fff file, you’ll be dealing with it again when the retouching is done.

2. Retouch the PSB

One thing to keep in mind is that you’re not (at this stage) dealing with noise reduction or color correction – here you just do the always-boring, zen-like practice of manual dust and scratches removal. Clone tool, Healing Brush, time and patience will be your friends.
Duplicate the background layer, call it “Retouching” or something else, zoom in and start retouching. If you happen to have a negative scan (which opens as a caramel pudding), I suggest you to add an Invert adjustment layer (which turns everything into a cyan flat-land) and above it a set of Curves adjustment layer (rough curves, just to restore a decent tone and color and make the retouching easier).

Mind you, do not make the Clone tool and the Healing brush sampling “All Layers”. Either “Current Layer” or “Current & Below” will be ok – if you wonder why, try it yourself.

When you’re done, remove the now useless adjustment layers and flatten the myScan.psb.

3. Paste the retouched layer in the 3F

Open both the original myScan.fff and the retouched myScan.psb. Drag the Background layer from the .psb and shift-drop it (i.e. do that pressing the shift key in order to auto-align it) into the 3F. You should have two layers in the myScan.fff now: the original below and the retouched above.

4. Save a copy of the retouched 3F

Flatten the myScan.fff. Leave it without any embedded ICC profile (remove it if necessary: Edit – Assign Profile – Don’t Color Manage This Document) and double check that it has a single Background layer only.

Now save the file as 3F (if you don’t find the Format: Imacon 3F in the saving options the 3F plugin hasn’t been installed correctly) with a different name, say myScan_clean.fff. If you have FlexColor already opened and pointing to the folder where the files are, close and reopen it in order to let the software read them again.

Caveat

FlexColor preview (at least when your 3Fs are very big – say a 6×12 cm at full resolution) isn’t based upon the actual file reading, but upon an embedded low-res image. Which is not affected by your retouching any way, so the 3F will keep showing dust and scratches. If you want to make sure your retouching has been applied, check it opening the Detail window (it’s the button with the magnifying glass icon): this forces FlexColor to read and show a portion of the actual file. Anyway, when you’ll export and the TIFF, it’ll be clean!

Filter Forge is a PS plugin; actually it’s more than a PS plugin, Filter Forge is a PS plugins’ container (some 9000 of them, freely available); no really, that’s not as exciting as the fact that Filter Forge lets you build your own PS filters. Visually. Oh listen: follow me in this Filter Forge introduction, I’m gonna show it to you – it’s easier than you think and a lot fun.

Filter Forge has been around for some years. As a technology is remarkably interesting, and now that it gets close to version 4 (currently in beta stage) I’ve decided that it was time to invest some of my money and start exploring it. Basically Filter Forge is both a Photoshop filter and a standalone image processing application (Mac/PC); it comes with several built-in algorithms (i.e. filters), but you’re allowed to download for free about ten thousands of them (not kidding: actual count is 9.388) from their website – made by a lively community of developers. Oh, and of course you’re invited to contribute, since filters building is implemented as a visual, node base operation of dragging & linking components, and rewarded even with a free copy of the software. Read along.

Textures and Effects

Filter Forge biggest strength appears to be texture creation (so if you’re doing any kind of 3D modelling work you should definitely take a look at it). I’m not too much into that, so I’ll just mention that it allows procedural texture creation – which means that you sort of put down the “texture formula” and the software will create the final bitmap resolution-independently, in a seamless tiling fashion. Which is kind of cool, to put it mildly: few examples as follows (look at them and keep whispering “procedurally generated, seamless tiled, 5.000 of them…“).

Soft Fur (by Heliagon), Suburbia (by ThreeDee), Biologic I (by Aurum), More Rough Wood (by Sharandra).
High resolution image are of course much more detailed than I’m allowed to show here!

Each texture, in turn, has its own set of generating parameters that you can tweak in order to get different results – and several ready made presets for your convenience.

Yes, you can procedurally generate this one too (Swiss Cheese, by Capadilla)

That said, it’ fair to say that FF engine is astonishingly powerful. 

Mind you: I’m not gettin paid from them to soak this post with wild enthusiasm, it is entirely in-house. I’ve purchased their software (version 3 + version 4 preorder) so I’m not biased. I’ve then decided to affiliate with’em because I really believe it’s a great product, so if you consider trying Filter Forge do it following this link, thanks!

But what interests me the most, because of my background as a PS retoucher (one life is always too short), are Effects filters – the kind of ones you’d apply to 2D pictures (contrast enhancing, artistic effects, etc). On FF website among the about 4.000 algorithms freely available there are true gems, many of which would compete with standalone plugins currently for sale.

Engraving (by Vladimir Gorovin), Sketchy Painting (by emme), Ice Age (by Crapadilla), Ranged Sharpen (by Skybase)

Filter creation

FF licensing scheme has three different offers: Basic, Standard and Pro. With the exception of the first one, you can build your own filters and (that’s truly amazing) modify any existing filter of the library. Say that you’re crazy about the Ice Age filter, and you wonder how on earth the author has been able to came up with something that funky.
Right click on the filter item, select “Edit filter” and voilà all the magic is explained (provided you can follow what happens):

Yep, that’s what a filter looks like, you’re peeping its algorithm. It’s made with a mix of components that you drag and drop on the workspace and combine together – so that the output of the first become the input of the following ones. And so on and so on – you’ve not to worry about memory management and writing code (even if there’s a LUA based scripting engine that you can work with, customizing your own components). You can really focus on the algorithm only.

To read the full features list, please see Filter Forge website.

Filter creation example

I’m going to show you one of my first (very basic I know, but hey I’m just a FF beginner!) experiments with Filters creation, which took me about 10 minuts from start to finish -

I’ve implemented Dan Margulis‘ “Bigger Hammer” technique, from his Picture Postcard Workflow (PPW). Dan also calls the Bigger Hammer “Shadows/Highlights on steroids”: basically we talk about a contrast normalization technique based upon an inverted overlay that boost highlights detail and help shadows too.

In Photoshop you’d do this way – the Layers palette should be pretty self-explanatory, top-down:

Darkening Layer: a copy of the background, Darken blending mode (opacity to taste) – use it to recover shadows darkness.

Overlay Layer: an inverted channel (either R, G, B) Gaussian Blurred, Overlay blending mode.

Background: the original image.

Unless you turn to scripting, to compare different channels for the overlay (say R instead of G) and blurring radii isn’t possible in real time. I’ve implemented such controls in Filter forge, so that you’re able to: switch  the channel for the inverted overlay (R, G or B); modify the Gaussian Blur radius; modify the Overlay layer and Darkening layer opacity (i.e both the overall effect’s and the Shadow recovering strength). As a plus, an overlay usually affect color as well – I’ve implemented it so that Luminosity only is altered. Anyway, here it goes.

1. Setting up the project

First thing I create a blank filter (Filter – New):

As you see, the Result component (what you’ll get from running the filter in PS) shows a red alert: it has no input yet. Let’s create one dragging from the Components column on the right, under External group, an Image component on the workspace; linking it to the Result. You do a link dragging the green output arrow of a component on to the green input point of another.

This is a dummy filter that does nothing, i.e. input is equal to output (but it works!). Notice that being italian I’ve selected a more appropriate placeholder image. Let’s start adding interesting pieces.

2. Extracting Luminosity

One important feature is to leave color alone working with a luminosity channel. FF implements RGB, Lab, HLS, HSB, and HSY colorspaces. Apparently, HSY lightness (Y) channel takes human perception of color into account: it looks promising, so I’ve added three Extract HSY components and one Assemble HSY to split and recombine channels, linking them as you see in the screenshot – from now on I’ll be dealing with the Y channel only.

3. Extracting R, G, B channels

I now need some channels to be used for the inverted layer blending (in overlay). I’ll stick to R, G, B for the clarity’s sake, but nothing would prevent me implementing Lab and HSY as well. So here they are three Extract RGB components hardcoded to output the desired channels (inverted, see the checkbox on the left column).

4. Building a Switch

FF implements Controls, which are a way to let the user, uhm, control the filter’s values. Alas, there’s no built in Radio-button set, so as a workaround I’ve to use a Switch component linked with an IntSlider. The Slider ranges 1-2-3, which enables the R, G, B positions of the Switch (i.e. 1=R, 2=G, 3=B).

5. Adding the Blur

Under the Processing group you can find built-in components for traditional image processing algorithm, such as Minimum, Maximum, Blend, Blur, High Pass, etc. I’ve added a Blur component with a Slider control, remapping it to a maximum value of 40 (I won’t get into remapping and percent values here). The slider will control the amount of blurring applied to the overlay channel.

6. Overlay Blend

FF comes with a Blend component that supports common PS blending modes and opacity. I’ve linked the original Y channel (as the background) to the blurred inverted channel (as the foreground), setting the blend to Overlay. Mind you, I’ve added a Slider control to tweak the opacity (that is: the effect’s strength). So far the big picture is as follows:

7. Shadow darkness

I’ve added a second Blend, using a second copy of the original Y in Darken (with a Slider controlling the opacity) to mimic the Darkening layer (as in the PS Layers palette screenshot depicts). This time the Y is the foreground, while the result of the overlay blend of the previous step is the Background:

8. Linking the Result

It’s time to un-link the Assemble HSY component from the Y channel coming from the Extract HSY, substituting it with the output of the chain of components ending with the shadow darkness blend. Now the filter is done! The complete pipeline is as follows:

You can now save it as a filter, adding info (such as instruction, author, description) and tags. FF allows you a before/after draggable split view, and the controls I’ve been adding are now automatically gathered in the Settings tab, ready to be modified on the fly:

Conclusions

I’m really excited to start experimenting with Filter Forge: its powerful processing engine and the peculiar way you build filters with it lead to remarkable results.

For instance, I’ve been able to replicate exactly my dear Photoshop Extension ALCE (Advanced Local Contrast Enhancer) and it took me, not kidding, about 5 minutes (which is kind of sad, if I think about all the PS extension development time in Extendscript + Actionscript).

Of course there’s room for improvement (on controls, for instance) – I’m confident that new version will keep advancing. As a developing platform is really amazing. The only actual big flaw (at least it’s a flaw from my own personal point of view) is that Filter Forge business model is build around the idea that the software value is boosted by the huge amount of free resources that come with it – that is, 9.388 filters created by skilled developers from all over the world. Moreover, you can open, study and tweak each one of them – and that’s definitely the better way to learn. Alas this business model collides with the possibility to compile your own filters into a binary form to sell them as standalone PS plugins. That’s not allowed: both for licensing reasons and because that way anyone could just grab one of the 9.388, pack and sell it (not fair, indeed).

It has to be acknowledged that Filter Forge has several interesting rewarding policies towards filters authors and contributors (a credits scoring system they use to assign free licenses) so they pursue their business model coherently – kudos to them!

Please visit Filter Forge for a full list of features, available filters and more!