Here is a list of Adobe Extension Manager ExManCmderror codes.

I don’t use zxpfiles to install my products, but some people do (e.g. with Anastasiy’s Extension Manager, that under the hood calls ExManCmd) and error numbers are always hard to decode. The list has been kindly provided by Adobe’s Erin Finnegan.

ExManCmd Errors

EXMAN_FAILED_INSUFFICIENT_PRIVILEDGE = -151,
EXMAN_FAILED_OPEN_FILES = -152,
EXMAN_FAILED_READ_FILES = -154,
EXMAN_FAILED_WRITE_FILES = -155,
EXMAN_FAILED_COPY_FILES = -156,
EXMAN_FAILED_DELETE_FILES = -157,
EXMAN_FAILED_CREATE_FILES = -158,
EXMAN_FAILED_FILE_TYPE_NOT_MATCH = -159,
EXMAN_FAILED_FILE_NOT_FOUND = -160,
EXMAN_FAILED_ITERATE_DIRECTORY = -161,
EXMAN_FAILED_FILE_EXISTS_ALREADY = -162,
EXMAN_FAILED_CHANGE_PERMISSION = -163,
EXMAN_FAILED_CREATE_DIRECTORY = -164,
EXMAN_FAILED_DIRECTORY_EXISTS_ALREADY = -165,
EXMAN_FAILED_IS_NOT_DIRECTORY = -166,
EXMAN_FAILED_IS_NOT_FILE = -167,
EXMAN_FAILED_PATH_INVALID = -168,
EXMAN_FAILED_PATH_NOT_FOUND = -169,
EXMAN_FAILED_ACCESS_DENIED = -170,
EXMAN_FAILED_FILE_LOCKED = -171,
EXMAN_FAILED_SHARING_VIOLATION = -172,
EXMAN_FAILED_JUDGE_FILE_EXIST = -173,
EXMAN_FAILED_FILESCHEMA_ILLEGAL = -174,
EXMAN_FAILED_ELEVATE_START = -175,
EXMAN_FAILED_ELEVATE_FILEDEL = -176,
EXMAN_FAILED_ELEVATE_FILECOPY = -178,
EXMAN_FAILED_ELEVATE_MAKEDIR = -179,
EXMAN_FAILED_UNHANDLED_EXCEPTION = -180,
EXMAN_FAILED_NO_INSTALLED_FILES = -181,
EXMAN_FAILED_ELEVATE_EXIST = -182,
EXMAN_FAILED_IS_NOT_LINK = -183,
EXMAN_FAILED_ELEVATE_ADDPERMISSION = -184,
EXMAN_FAILED_EXTRACT_ZXP = -201,
EXMAN_FAILED_DECRYPT = -202,
EXMAN_FAILED_ENCRYPT = -203,
EXMAN_FAILED_PARSE_XMANCONFIG = -251,
EXMAN_FAILED_PARSE_MXI = -252,
EXMAN_FAILED_DESTINATION_MISSING_TOKEN = -253,
EXMAN_FAILED_PARENT_FOLDER_IN_PATH = -254,
EXMAN_FAILED_SOURCE_FORMAT_ERROR = -255,
EXMAN_FAILED_UNKNOWN_TOKEN = -256,
EXMAN_FAILED_MANIFEST_NODE_NOT_FOUND = -257,
EXMAN_FAILED_XML_NOT_FOUND = -259,
EXMAN_FAILED_ELEMENT_NOT_FOUND = -260,
EXMAN_FAILED_INVALID_VALUE_IN_MXI = -261,
EXMAN_FAILED_OPEN_XMANCONFIG_URI = -262,
EXMAN_FAILED_DOWNLOAD_XMANCONFIG = -263,
EXMAN_FAILED_PARSE_TODOFILE = -264,
EXMAN_FAILED_PARSE_XML = -265,
EXMAN_FAILED_GENERATE_XMANCONFIG = -266,
EXMAN_FAILED_INVALID_MANIFEST = -267,
EXMAN_FAILED_INVALID_MANIFEST_VERSION = -268,
EXMAN_FAILED_INVALID_MANIFEST_BUNDLE_ID = -269,
EXMAN_FAILED_INVALID_MANIFEST_BUNDLE_VERSION = -270,
EXMAN_FAILED_MANIFEST_EXCEPTION = -271,
EXMAN_FAILED_RESOURCE_EXCEPTION = -272,
EXMAN_FAILED_BLOCK_LIST_EXCEPTION = -273,
EXMAN_FAILED_INVALID_BLOCK_LIST = -274,
EXMAN_FAILED_CLOSE_HEADLIGHTS_SESSION = -302,
EXMAN_FAILED_INIT_HEADLIGHTS = -303,
EXMAN_FAILED_NULL_POINTER = -351,
EXMAN_FAILED_BUFFER_NOT_ENOUGH = -352,
EXMAN_FAILED_REJECT_LICENSE_AGREEMENT = -401,
EXMAN_FAILED_SIGNATURE_VALIDATION = -402,
EXMAN_FAILED_NO_PRODUCT_SUPPORT_THIS_CEP = -403,
EXMAN_FAILED_CEP_NOT_SIGNED = -404,
EXMAN_FAILED_REJECT_SIGNATURE_VALIDATION = -405,
EXMAN_FAILED_EXTENSION_NOT_FOUND = -406,
EXMAN_FAILED_REQUIRED_EXTENSION_NOT_INSTALLED = -407,
EXMAN_FAILED_REQUIRED_EXTENSION_NOT_ENABLED = -408,
EXMAN_FAILED_EXTENSION_BLOCKED = -409,
EXMAN_FAILED_INVALID_ZXP_FILE = -410,
EXMAN_FAILED_NO_SUPPORTED_PRODUCT = -411,
EXMAN_FAILED_CONFLICT_EXTENSION_FOUND = -412,
EXMAN_FAILED_INVALID_EMBEDDED_EXTENSION = -413,
EXMAN_FAILED_EMBEDDED_EXTENSION_NOT_SIGNED = -414,
EXMAN_FAILED_RESOURCE_FOLDER_NOT_FOUND = -415,
EXMAN_FAILED_CREATE_EXTENSION = -416,
EXMAN_FAILED_WRONGDEPENDENCY = -417,
EXMAN_FAILED_NEWER_EXTENSION_INSTALLED = -418,
EXMAN_FAILED_DEPENDENCY_CHANGED_WHEN_UPDATE = -419,
EXMAN_FAILED_MXP_NO_SUPPORTED = -420,
EXMAN_FAILED_DOWNLOAD_EXTENSION = -421,
EXMAN_FAILED_REJECT_OVERWRITE_CONFLICT_EXTENSION = -422,
EXMAN_FAILED_USER_CANCEL_DOWNLOAD = -423,
EXMAN_FAILED_CAN_NOT_INSTALL_FOR_ALL = -424,
EXMAN_FAILED_PRODUCT_NOT_FOUND = -451,
EXMAN_FAILED_TOKEN_NOT_FOUND = -453,
EXMAN_FAILED_PRODUCT_NOT_SUPPORTED = -454,
EXMAN_FAILED_PARSER_PRODUCT_TOKEN = -455,
EXMAN_FAILED_POINT_PRODUCT_NEED_QUIT = -456,
EXMAN_FAILED_SPECIFIER_NOT_FOUND = -457,
EXMAN_FAILED_REQUIRED_PRODUCT_NOT_INSTALLED = -458,
EXMAN_FAILED_REQUIRED_VERSION_NOT_INSTALLED = -459,
EXMAN_FAILED_DBWRAPPER_COMMON = -500,
EXMAN_FAILED_DBWRAPPER_CONNECTFAILED = -501,
EXMAN_FAILED_DBWRAPPER_DISCONNECTFAILED = -502,
EXMAN_FAILED_DBWRAPPER_QUERYFAILED = -503,
EXMAN_FAILED_DBWRAPPER_NOTSTARTUP = -504,
EXMAN_FAILED_DBWRAPPER_NOTSHUTDOWN = -505,
EXMAN_FAILED_DBWRAPPER_DATANOTFOUND = -506,
EXMAN_FAILED_DBWRAPPER_CREATTABLFAILED = -507,
EXMAN_FAILED_DBWRAPPER_NAME_EXIST = -508,
EXMAN_FAILED_UPDATE_DATABASE = -509,
EXMAN_FAILED_INIT_BT_FAILED = -552,
EXMAN_FAILED_VALIDATE_LICENSE = -601,
EXMAN_FAILED_GET_USER_ACOUNTDAT = -602,
EXMAN_FAILED_INVALID_USERACOUNT = -603,
EXMAN_FAILED_GET_LICENSE_CHECK_RESPONSE = -604,
EXMAN_FAILED_COMMON_EXCEPTION = -651,
EXMAN_FAILED_SSL_CONTEXT_EXCEPTION = -652,
EXMAN_FAILED_SSL_EXCEPTION = -653,
EXMAN_FAILED_COMMON_SET_MGMT = -851,
EXMAN_FAILED_STRING_CONVERT = -901,
EXMAN_FAILED_USER_NOT_FOUND = -902,
EXMAN_FAILED_FETCH_USER_INFO = -903,
EXMAN_FAILED_GET_USER_HOME_FOLDER = -904

After 10 months since the launch of the Early Access Program, I am incredibly happy to announce that my book is now complete! Read the full report below.

The Final Version 1.0!

The book is now 12 Chapters/409 pages, fully CC 2019 compliant: compared to the last EAP version 0.2, I’ve added one Chapter, an Appendix, a proper Acknowledgement section, some extra-content on ActionManager, and given it a final round of proofreading and fixes.

I’ve also finally credited my dear friend and colleague Sandra Voelker for her work as the Technical Editor – she’s been providing suggestions and corrections of remarkably high value.

I am also especially honored to tell you that the book contains an awesome Foreword by Jeffrey Tranberry, Sr. Product Manager, Digital Imaging at Adobe Systems, and author with Geoff Scott of the book “Power, Speed & Automation with Adobe Photoshop” (2012).

All in all, I am quite happy about how it has turned out: it took me just two years and a half! Dare I to say, you won’t find anywhere else such a comprehensive learning path that goes from the basics of the ExtendScript language, up to advanced topics such as ActionManager (~70 pages) and Adobe Generator (~60 pages).

The book V1.0. is for sale right now at PS-Scripting.com, where you can also

I really hope you’ll enjoy it! As I wrote in an earlier post, my intention is to match the Adobe Photoshop HTML Panels Development course and add a series of video tutorials: I tested the equipment but stopped for the final rush needed to publish the book.

Many thanks to all who have contributed, helped, and supported the project buying the EAP Your support has been truly appreciated
Thank you all!

Book Website

In a previous post I’ve introduced the recently open-sourced Spectrum CSS. Here, I’ll be demonstrating how to use them to build a simple Vue.js component: a DropDown menu.

Spectrum CSS are really appealing, but as I’ve mentioned earlier, they’re not bundled with any JavaScript – besides what you may borrow from the online documentation page. While elements such as Sliders are plug & play, for they actually do use a <input type="range"> wrapped in a lot of finely styled <div> tags, others such as the DropDown are not.

I.e. if you click on a Closed dropdown, it won’t open (the above is just a screenshot so it’s pointless to try, but the result would be the same). The reason being that a Spectrum DropDown is not really a <select> element, as you can see in the snippet below:

As far as I get, re-creating an element from scratch is a standard practice to avoid rendering differences between browsers (the <select> is a good example here).

Anyways: no <select> means no default behavior on click, change, etc. In other words, you are the one in charge of populating the <div> elements above and adding relevant event handlers so that the DropDown stops being a nice but still and useless object.

This is a perfect test case for encapsulating everything in a Vue.js Component! The only drawback is that I don’t feel particularly comfortable with the idea of creating Components from scratch. All my CEP Panels use Vue.js now, that’s true, but frankly in a very simple and not over-engineered fashion: I’ve always used one shared data, the farther I’ve ventured into fanciness was setting up an Event Hub.

Thanks god I’ve a PhD in Copy&Paste, so I’ve been able to adapt this one:

… into a proper Vue Component that wraps the Spectrum DropDown original markup. The .vue file I came up with is as follows:

I won’t go too much into the details here. If you look at the <template> tag and compare it with the original Spectrum html, you can spot the differences: I’ve added a couple of classes that depend on the selected item or the showMenu boolean, and used a v-for loop to populate the options.

The <script> tag is where the actual logic belongs: I’ve added two methods, one to show the opened dropdown and one to emit an event to the parent when something is selected. From the props you’re able to tell how to consume such element, e.g.:

<drop-down :options="arrayOfObjects" v-on:updateOption="methodToRunOnSelect" placeholder="Select a thing..."/>

The result is this one:

It is quite bare, I may want to add transitions and such… but it works!

To tell you the truth, I thought I couldn’t be able to make it: I had a look at proper Vue.js UI Kits (like this one) and they exceed, by far, my understanding. Luckily I’ve been able to borrow code and adapt it, so I may be doing it again in the future for other elements that I would need.

If you’re up for the same thing, or you know how to make my code better, please let me know in the comments. Bye!

Please do yourself a favour and read this Medium post by Lead Technical Evangelist Ash Ryan Arnwine about the future of the ExtendScript ToolKit.

I’ll keep it short because I urge you to read the original news. No ETA yet, but ESTK is gonna die soon won’t be re-written to comply with Apple’s 32bit applications ban (macOS-next). Nobody in their right mind would have thought it anyway, but we’ve got an official confirmation.

[confetti fall from the sky]

Go download Visual Studio Code and familiarize with it, while waiting for the new Adobe Scripting plugin (Mac/Win compatible) to be released.

The CSS is demoed in this page, where you can pick four themes (Lighter, Light, Dark, Darkest) in four scales (Medium, Large, Medium diff, Large diff).

The component list, compared to Topcoat which I’ve been using extensively in my projects, is quite larger – and frankly perhaps a tad overkill for CEP Panels, e.g. I doubt I would ever use a Calendar. But I’ve never complained of abundance: nice and very welcomed features are all kind of sliders, including ranges, and split-buttons, steppers, etc.

You can read in the documentation page that:

We have found that JavaScript is where a framework or library quickly becomes opinionated and stops being easy to use with or across other frameworks. To avoid this problem, Spectrum CSS avoids implementation details that require JavaScript. Where an element might require multiple states, the documentation here will simply show all the states in a flat, static example. We leave it to the frameworks implementing Spectrum CSS to create JavaScript that suits their needs.

Which means that we’re left on our own, but that’s not a big issue I suppose – hopefully there will be a Vue.js Spectrum components implementation in the near future 🙂

The state of the Blog

That was it for Spectrum CSS, I take the chance here now to inform you about blog updates, etc.

As a matter of fact, I’ve slowed down things quite a bit as you’ve noticed: I took fewer Panel jobs and tried to focus on books and courses. I’ve had greatly unwelcome issues with my house’s restoration works (started a couple of years ago – both the works and the issues…) that proved to be a time/concentration/money sink. As a result, progress on development-related tasks have been erratic, to say the least.

Recently, I try to record a couple of test videos to be bundled with the Professional Photoshop Scripting course, which will look more or less like this:

There is no ETA yet – I will be able to tell you more as soon as I get the estimate for the roofing works, which will be followed by the insulation works, then the stairs, etc. Hopefully, before my hair gets completely gray

Thanks for reading and for your support!

nowhere else

Adobe Generator is an amazing and very little known technology available in Photoshop since version CC. It features a Node.js instance running in the background that you can use in a variety of interesting ways.

I’ve built several Generator Plug-ins expressly for this book: Pixmap extraction, Artificial Intelligence via an external service, Photoshop remote control from the Browser, bi-directional Socket communication, just to name a few. I’m sure you’ll enjoy them! Did you know that Adobe Generator has got its own icon? 🙂

This marks Professional Photoshop Scripting EAP version 0.2 – I would say that the main content is already in place. I plan to gather minor topics in one or two chapters, then proceed with the publication. You can still buy it at a highly discounted price now!

The Final Product:

• Final Book + Code, $149
• Final Book + Videos + Code, $249
• Final Book + Videos + Code (Team/Enterprise License), $499

Early Access Program (current)

• Early Access Book + Code, $99
• Early Access Book + Code (Team/Enterprise License), $199
• Discount Coupon for the Videos when they will be recorded

Visit ps-scripting.com for details. Cheers! ]]> https://www.davidebarranca.com/2018/06/professional-photoshop-scripting-eap-update/feed/ 2 https://www.davidebarranca.com/2018/05/automated-check-for-corrupted-image-files-with-python-and-imagemagick/ https://www.davidebarranca.com/2018/05/automated-check-for-corrupted-image-files-with-python-and-imagemagick/#comments Mon, 07 May 2018 23:20:19 +0000 http://www.davidebarranca.com/?p=3337 How do you check if an image file (tiff, psd, psb) is corrupted, other than looking at its thumbnail with Bridge, or opening it on Photoshop? With a small Python script and ImageMagick! Read along.

Background

The client of mine I work as a retoucher for had some problems with the so-called Data Migration (the dull, time consuming, and error prone process of transferring a lifetime backup from old, once very expensive external drives to a set of new, somehow still equally expensive external drives). As a result, he got some corrupted files here and there in the destination drives – that’s the reason why you migrate data: the source has insufficient capacity, it has become unstable, obsolete, or both combined.

Problem is that we’re talking about several TB of data, mostly as .psb files (ranging from about 1 up to 20GB each), and it goes without saying that opening them all in Photoshop is not an option; nor you can trust Adobe Bridge thumbnails – provided that you’ve set the preferences to render previews for big files too – because it’s a manual process anyway. Even if I’m paid by the hour, staring at thumbs is not my preferred way to get blind.

After some research, I’ve found no way (other than the one I’m about to describe) to check for psd/psb files corruption in an automated fashion. Which seems to me quite odd – if you have better, i.e. faster and/or simpler, solutions, please do suggest them to me in the comments below.

What you need

Python 3, and ImageMagick. Both will work either on Mac or Windows: I’ve no experience of them on the latter platform, so I will just assume that you will be successful in following the installation instruction provided in the official home pages. PC owners: read at least the part relative to ImageMagick. Mac users: read it all.

Python 3

If you’re on a Mac like me, you already have Python installed. Chances are that it is version 2.7, or another one but 3. Open the Terminal and type:

$ python --version
Python 2.7.10

This is what I still get after having installed Python 3.6 myself, via Homebrew. I’m no Python expert, so it took me some Google time to understand that on a Mac you can still have the python command pointing to the System’s old 2.7 version, even if you’ve freshly installed the new one.

Solutions involve manually changing symlinks (power users advise against it), or using one of the available packages to create isolate Python environments (e.g. virtualenv, pyenv, etc. A list of them is found here). I couldn’t make neither of them to work in a reasonable amount of time, so I’ve resorted to simply use the python3 command, e.g.

$ python3 --version
Python 3.6.2

ImageMagick

ImageMagick is a multiplatform, open source commandline utility that performs a huge amount of tasks on all kinds of image files. I’ve installed via Homebrew, but it turns out that, at least on the Mac, it doesn’t come by default with the proper Delegates (aka Libraries) to deal with .psb files, which is what I needed the most.

Finding the proper way to do so proved almost impossible to me: while reading the source code documentation (the last thing I wanted to do was to compile it from the source), I’ve discovered that via Homebrew you can list all the possible installation options for a package:

$ brew options imagemagick

--with-fftw
	Compile with FFTW support
--with-fontconfig
	Build with fontconfig support
--with-ghostscript
	Build with ghostscript support
--with-hdri
	Compile with HDRI support
--with-liblqr
	Build with liblqr support
--with-librsvg
	Build with librsvg support
--with-libwmf
	Build with libwmf support
--with-little-cms
	Build with little-cms support
--with-little-cms2
	Build with little-cms2 support
--with-opencl
	Compile with OpenCL support
--with-openexr
	Build with openexr support
--with-openjpeg
	Build with openjpeg support
--with-openmp
	Compile with OpenMP support
--with-pango
	Build with pango support
--with-perl
	Compile with PerlMagick
--with-webp
	Build with webp support
--with-x11
	Build with x11 support
--with-zero-configuration
	Disables depending on XML configuration files
--without-freetype
	Build without freetype support
--without-jpeg
	Build without jpeg support
--without-libpng
	Build without libpng support
--without-libtiff
	Build without libtiff support
--without-magick-plus-plus
	disable build/install of Magick++
--without-modules
	Disable support for dynamically loadable modules
--without-threads
	Disable threads support
--HEAD
	Install HEAD version

So, after a first installation (without psb support), with no clear hint about the proper option(s) to use in my case, and even less spare time to test, I’ve chained them all – at least the seemingly appropriate ones, with little worries about being redundant. At all events, no one was watching me, nor would have ever known The embarrassing line I’ve used is:

brew reinstall imagemagick  --with-fftw --with-fontconfig --with-ghostscript --with-hdri --with-libde265 --with-liblqr --with-librsvg --with-libwmf --with-little-cms --with-little-cms2 --with-opencl --with-openexr --with-openjpeg --with-openmp --with-pango --with-perl --with-webp --with-x11

It worked, so I was a happy camper.

The Python Script

Which is far from perfect, but it does the job – I’m sure that a proper Python developer can make it much better: it comes from surgical copy&paste from various Google Search result, plus a very light editing on my side.

import os
from subprocess import Popen, PIPE

folderToCheck = '/Volumes/16TB/whatever/path'
fileExtension = '.psb'

def checkImage(fn):
	proc = Popen(['identify', '-verbose', fn], stdout=PIPE, stderr=PIPE)
	out, err = proc.communicate()
	exitcode = proc.returncode
	return exitcode, out, err

for directory, subdirectories, files, in os.walk(folderToCheck):
	for file in files:
		if file.endswith(fileExtension):
			filePath = os.path.join(directory, file)
			code, output, error = checkImage(filePath)
			if str(code) !="0" or str(error, "utf-8") != "":
				print("ERROR " + filePath)
			else:
				print("OK " + filePath)

print("-------------- DONE --------------");

How it works

The basic is the identify call (that comes from ImageMagick), which is set to -verbose. This is what performs the check: the rest is just looping through the filesystem, looking for the appropriate file extension, and logging a message.

How to use it

Save this on a file with a .py extension, and then run it with the python3 command on a terminal, e.g.

$ python3 check.py

Before doing so, do change the content of the folderToCheck variable with an actual folder on your disk (with absolute path), and the fileExtension too: I’ve used .psb, but you can change it to .psd, .tif, .jpg, etc. As a result you’ll get a log in the Terminal; I’ve used a nifty, cheap application called Code Runner for such tests, and this is the result:

As you see, I’m just logging OK/ERROR with the path, very basic. What to do with this newly acquired piece of knowledge is up to you.

Please note that:

• The script processes nested folders too.
• It is awfully slow and hungry: it eats CPU cycles and RAM. But it’s automatic, so heck!
• The file extension is case sensitive, so ".JPG" is different from ".jpg".

How to make it better

Few suggestions for the skilled Python developer (which I’m not, alas)

• Write on a log file instead of the console
• Keep track of the processing status and resume from there
• Display the advancement status (say, “image 34 of 320”)
• Make the file extension case insensitive.

If you know how to do any of this, please share your knowledge in the comments! Thank you!

The course that I have announced in the past is now near completion: I would say 3/4 of the topics that I plan to cover have been written and edited – I’m at page 339 and counting! It took me way more than expected, though.

Early Access Program

In a fashion that is nowadays quite common among technical writers, I have opened what is referred to as an “Early Access Program”. If you’re not familiar with it, the idea is that you are able to read the book as I finish writing it. The advantages:

• You don’t have to wait for the final book to get started.
• You’ll be sent a notification and download link as soon as further updates are ready (new Chapters, fixes, etc).
• You can get the course at a ludicrously discounted price now, compared to book’s street price when it’ll be published.
• You can contribute to the writing process with suggestions and feedback.

Sounds good?

Full Course and Pricing

This one will follow exactly the same price/bundle scheme of my previous Adobe Photoshop HTML Panels Development course.

The Final Product:

• Final Book + Code, $149
• Final Book + Videos + Code, $249
• Final Book + Videos + Code (Team/Enterprise License), $499

Early Access Program (current)

• Early Access Book + Code, $99
• Early Access Book + Code (Team/Enterprise License), $199
• Discount Coupon for the Videos when they will be recorded

To be clear, the Early Access Program entitles you to all the work-in-progress updates, and the Final Release version too. Since I will record the videos when the book is completed, you’ll have access the video content as an optional upgrade.

Launching ps-scripting.com

The course is for sale since April 23rd 2018, please head to the dedicated website www.ps-scripting.com! And help me to spread the world.

Go to ps-scripting.com!

Everywhere you go you read about Luminosity Masks – I’m really surprised it doesn’t have its own Wikipedia Page! (Maybe I’ll take care of that).  It is truly a great tool to have in your toolbox, very powerful when used correctly. It’s greatness by simplicity. But how does it works? Not in the sense “how to create it”, but what really happens behind the scenes?

Well, let’s try answering that question, and doing it in a deep (and hopefully interesting) way.

The Basics

Step 1 – It all starts with a Grayscale image

You can have images with all the colors in the world, but the first step in creating a Luminosity Mask is getting a Grayscale image (a Single Channel Image). In most cases, it means to calculate the Luminosity Channel of the given image. Each one has his own recipe: most actions/panels based solutions use Photoshop Luminosity selection (Ctrl + Left Mouse Click on the RGB Channel in the Channels Palette).

By the way, any “Single Channel” image can do here. The best choice (i.e. Channel, or processed grayscale layer) is the one where the image features you want to select are more evident and easily separable from the rest – in the above example the trees are well distinct from the sky for instance, and the lake’s gradient below helps as well.

The Channel of choice could be the Blue from RGB, the Magenta from CMYK, or a combination of all the 10 Channels an image provides (R, G, B, C, M ,Y, K, L, a, b): whatever, be creative. In case of a grayscale image, life is easier, just move over to Step 2.

Step 2 – Apply Pixel Wise Transformation on the Grayscale Image

Now, this is where the magic happens. The idea is very simple: given the Gray Scale image as input, the output per pixel is a function of its value only.

Well, this sentence might take some of us back to horrible school days but it is really simple when you think about it. Pixel comes in, states its value, and gets an output value based only on its value alone, and voilà! We have a Luminosity Mask.

The name says it all, the Mask depends solely on the Luminosity (Tonal Range value) of the pixels. It has nothing to do with their location, not their surrounding pixels. Just using the Luminosity value. Nothing more, nothing less – power by simplicity.

The above Figure represents a Mask Generator.

The input pixels values are in the upper section. They get processed by this black box, which operates based on a function \(f \left( x \right)\) and the pixel output that is generated is found in the bottom section. At the output, everything is black (Low Values) with the exception of pixels around 128, that are mapped to white (High Values). This suggests that a “Midtones Mask” has been generated.

Simple fact: images are discrete in their values. For instance, in the case of an 8bit image, the discrete values are in the range {0, 1, …, 254, 255}, occupying 256 available slots, i.e. \({2}^{8}\).

So a Mask Generator (Luminosity Mask Generator) has to designate an output value for each value in the input discrete domain.

If the output image is also, let’s say 8 Bit, then the output values are also within the range {0, 1, …, 254, 255} which means one need to map 256 values into 256 values. In the Computer Science world this process is done using a Look Up Table (LUT).

Over time some masks got their own naming according to the properties of the values assigned:

• If it designates high output values to low input values, and low values to the rest it is called Shadows Mask Generator. The output mask is called Shadows Luminosity Mask which reveals shadows and blocks everything else.
• If it designates high output values to mid input values, and low values to the rest it is called Midtones Mask Generator. The output mask is called Midtones Luminosity Mask which reveals midtones and blocks everything else.
• If it designates high output values to high input values, and low values to the rest it is called Highlights Mask Generator. The output mask is called Highlights Luminosity Mask which reveals highlights and blocks everything else.

This is the mask generation transformation (aka mapping), and basically this is all theory there is to know.

Examples

Let’s do some stretching by examining two simple examples of main building blocks in the Luminosity Mask world. We will assume an 8bit image, hence input and output pixel values are given by {0, 1, 2, …, 254, 255}.

The most basic Mapping / LUT / Function (all are different names to the same idea) is the identity mapping:

\(f \left( x \right) = x\)

Namely, the output value – that is \(f \left( x \right)\) – is identical to the input value, which is \(x\).
This mask is called Highlights Luminosity Mask. Why? Because low input values (Shadows) are mapped to low output values (Dark pixels), and high input values (Highlights) are mapped to high output values (Light pixes). The result is a mask where shadows are dark (not selected) and highlights are light (selected) – hence the name.

Another basic mask is given by the negative (inverse) of the Highlights Mask which is the Shadows Luminosity Mask:

\(f \left( x \right) = 255 – x\)

Here, to low input values (shadows) correspond high output values, and to high input values correspond high output values (light pixes). The result is a mask where shadows are light (selected) and highlights are dark (not selected).

Using those 2 building blocks one could generate many other masks targeting different Tonal Ranges – something we will get to later.

As can be seen above, the Midtones Mask is generated by scaled multiplication of the Highlights Mask and the Shadows Mask. This is one way to achieve this, not necessarily what’s used usually (we’ll talk about that). Moreover, as can be seen by the Harmonic Function, one could do any mapping one wish.

Remark: in practice, data is scaled into [0, 1] range as operations, such as multiplication, makes more sense in that domain. So the range {0, 1, 2, …, 254, 255} becomes {0 / 255, 1 / 255, 2 /255, …, 254 / 255, 255 / 255}. This is exactly what’s done in the above figure.

In Practice

So now we know what a Luminosity Mask Generator is, and what it is doing. On the next step, let’s try to understand how this is done in Photoshop in most cases.

As discussed above, one need to create a LUT and there are two main approaches doing so: the Calculations Tool or the Curve Tool.
One can apply each of those on Grayscale Image and the output is basically a Luminosity Mask.

Curve Tool

The Curve Tool is a LUT table visualized by a Curve. It practically lets the user draw the LUT using a flexible curve.

On the figure above, one could see Photoshop’s Curve tool. On its bottom, horizontally, you can see the input values. On the left, vertically, you can see the output value. You match between each value just by altering the curve according to your wish. Basically, school days function, that’s what it is, drawing a function.

Luminosity Mask Recipe by Curve Tool

1. Create a Grayscale version of the image in a new layer (Extract Luminosity / select one of the channels / desaturate the image / use Channel Mixer, etc…).
2. Open the Curve Tool.
3. Draw the desired LUT.
4. Use the result as a mask -> Luminosity Mask.

Calculations Tool

Using Calculations Tool one could apply simple Math operations on Layer / Channel / etc… Namely we can combine Math operations (Add, Subtract, Multiply and even more esoteric functions) by repetitive use of the Calculation tool.

For instance, using the Calculation Tool we could easily generate the Midtones Mask from above by multiplying a layer and its inverse and scaling result by 4. So it gives us the option to use +, –, *, / on images, but not much more than that.

Comparison – Curve Tool vs. Calculations Tool

Let’s summarize the differences between those 2 approaches:

Building Masks

In this part we will show how most of the masks out there are built using the Lego bricks we created.

As one could see above, using Addition, Subtraction and Multiplication (Intersection), all operations available on Layers / Channels / Masks in Photoshop, one could easily generate all those “Classic” Luminosity Masks one could find in the wild (wild world of the Luminosity Masks Panels).

Those with sharp eye would pay attention to something strange: Midtones Mask 001 is all black, see the function below:

\(f \left( x \right) = 1 – x – ( 1 – x ) = 1 – 1 + x – x = 0\)

Yet in practice, in all products out there… It is not?! So what’s going on?  Clearly they all state that the Midtones Mask is created by subtracting the Highlights and Shadows masks from the all white mask. So it is, by all means, should be all black mask while it is not.

Well, what you see above is ideal Masks, while Photoshop can not generate them in this quality.  The current methods to create them usually use Photoshop’s steps which aren’t doing this exact Math.

We’ll talk more on those pitfalls and strange behavior of classic Luminosity Masks (and their generation) in the next writing.

Summary

• Now we’ve understood what Luminosity Masks really are, the actual operations and Math behind them.
• We have shown the Luminosity Mask generation is no more than the most simple operation on grayscale image – Apply LUT / Pixel Wise Mapping.
• What we saw is that there 2 main approaches for Luminosity Masks in Photoshop. While one gives the most flexibility and efficiency (Curve Tool) it lacks with quality and the other which generates smooth masks (Calculation Tool) has speed issues when trying to generate complex masks and some miss calculations in the process.

How can we solve those? Well, do the algorithm outside the limitations of Photoshop. This is what Fixel Zone Selector is all about. In the next part we’ll have a deeper dive and talk about Zone Selector’s approach to Luminosity Masks.

Image Credit

Lighthouse Image – Credit to magnetismus.
Schwaigsee Lake – Credit to Alfred Borchard.
Simple Living – Credit to Malcolm Carlaw.

Resources

Luminosity Mask: The Complete Kickstarter’s Guide.
Video – How to Generate the Classic Luminosity Masks Using Mask / Channel Operations (Add, Subtract, Intersect Multiply).
Video – How to Generate the Classic Luminosity Masks Using Calculations (16 Bit Mode).
Video – Selecting Using Luminosity Masks (Using Curve Tool).

Author of this guest post: Scott Murdock. ]]> https://www.davidebarranca.com/2018/03/luminosity-masks-how-does-it-really-work/feed/ 3 https://www.davidebarranca.com/2018/01/ultimate-guide-native-installers-automated-build-system/ https://www.davidebarranca.com/2018/01/ultimate-guide-native-installers-automated-build-system/#comments Tue, 23 Jan 2018 13:37:47 +0000 http://www.davidebarranca.com/?p=3195 After Adobe Photoshop HTML Panels Development, I’ve now published a new Course, titled “The Ultimate Guide to Native Installers and Automated Build Systems”!

For which title the gods of software development and copywriting will forgive me.
Curious?

In the business of Adobe HTML Panels, sooner or later you’ll ask yourself: “how the heck do I do… whatever it must be done to let my customers run my software on their Computers?”
The typical stream of consciousness is as follows.

I know I know: it’s just a matter of moving a folder to the right place, isn’t it? And perhaps few extra assets here and there… of course, I don’t want other developers to reverse engineer my own code, so it must be protected somehow. OK, I forgot signing and timestamping. And Code Certificates: should I buy one? Which one? Do they all work the same? I’ve heard that some classy people build Native Installers, like Apple and Windows programs with nice graphic interfaces, that defeat Gatekeeper and SmartScreen security warnings like a pro! Gee, do I have to go through all this, by hand, all the time? Each time I change my code, on each product? For real?

Stream of consciousness ends on a sad note.
Hey, look at that! (Spring from Vivaldi’s The Four Seasons plays in background)

This is what the cool guys are doing. Type a command, and look at things that build themselves.

What is looping above is a sample project, including:

• Input:
  • HTML Panel
  • Multiplatform Photoshop Plugin as .plugin and .8bf files (optional).
  • Readme documentation as a .pdf file (optional).
• Output
  • Signed and Timestamped Panel folder with:
    • .js files protected with advanced obfuscation algorithms.
    • .jsx files exported as .jsxbin with different advanced obfuscation algorithms.
  • Zipped version for convenience.
  • Hybrid Extension as a .zxp file, ready for submission on Adobe Add-ons.
  • Mac .dmg package, that in turn contains:
    • a .pkg native installer,
    • an uninstaller application,
    • the .pdf documentation.
  • Windows .exe native installer that deploys Panel, Photoshop Plugin and Documentation
    • Uninstaller provided in Windows’ Control Panel.
  • Both platforms’ native installers are signed with paid Code Certificates to comply with Windows and macOS security policies.

After many years of trial and errors, I’ve finally settled to the above setup for my own commercial products, which takes 20 seconds of computer work to automatically build all the above. The final result looks like that, first on Mac:

Then on Windows:

The Course

How to get there? I’ve explained it all, step by step, in The Ultimate Guide to Native Installers and Automated Build Systems, my new Course!

It comes as a PDF ebook, bundled with the entire Sample Project code – both the dummy Panel and assets, plus the automation.

The course draws the big picture first, aka what needs to be done; then shows you how to manually perform each step, why, suggesting best practice and which software to use; finally, it teaches you how to write and customize the code to build the entire automation pipeline.

FAQ

Does the Course apply to Photoshop only?
I’ve used PS as my Adobe app of choice, but no, the course applies to every CEP-enabled app you’re developing extensions for.

Mac, Windows or both?
I’m on Mac: it’s the only platform that allows you to build both Mac and Windows installers; yet the automation code can run on Windows as well, with the exception of the Mac installers part.

Does the bundle include Code Certificates?
No. On the one side, paid Code Certificates are strongly suggested but optional. On the other side, I could not buy them in your place! In fact, it took me quite some time and effort to acquire them just for myself.

Does the Course cover Panels development?
This one is about installers and automation only. If you want the Big One (300 pages, 3 hours of videotutorials, 28 sample Panels code), head to the Adobe Photoshop HTML Panels Development Course.

Why there’s a 1 in the cover?
You have a sharp eye! I plan to expand the collection with more specific and smaller Courses like this one, in the future. Feel free to suggest topics you’d like to see covered in the comments! And yes, I have a as the Terminal prompt, isn’t it cute?

Thank you!

Over the years, I’ve always posted articles on this blog as a way to give back to the developers’ community what I’ve picked up myself in the first place – from Forums, chats, etc. Alas, we live in a (very) material and a (very) demanding world: projects like this one are fundamental for me to sustain my business and my family – and as a consequence maintain and update this blog too.
Thank you in advance for your support! It is really appreciated.