Known Participant

Question

How to accelerate speed / reduce runtime of gigantic Photoshop batches/scripts?

Forum|Forum|2 years ago
July 5, 2023
5 replies
2488 views

Part of my automated workflow involves running 13 total steps on a large number of images (1000+). While this entire workflow is fully automated, the runtime is gigantic (5-10 hours, for the recent batch sizes), given how many image files it's processing.

What are some of my options for effectively reducing the runtime of this Photoshop script?

The obvious options include: eliminate steps; get a faster computer with better hardware; reduce the Photoshop file sizes so it can process faster; and dedicate more CPU resources during runtime to the program so it can execute faster.

Are there any other solutions I'm missing that help to speed up batches and scripts? Maybe writing the code differently so it more efficiently performs the actions?

Just looking for some good ideas for how I can reduce the runtime.

Thanks!

This topic has been closed for replies.

R

r-bin

Legend

Theoretically (I did not check) you can split the folder into 10 parts, run 10 photoshops at the same time and start your own process in each to process the desired subfolder.

T

the_king_of_goatsAuthor

Known Participant

Without having tested it, I feel quite confident that running 10 parallel instances of Photoshop would absolutely slow my computer to a crawl. Maybe if I had 200 GB RAM, lol.

c.pfaffenbichler

Community Expert

• Use AM-code instead of DOM-code if possible (for example to replace the for-clause »for (var i = 0; i < layers.length; i++) {«)

• Hide the Panels

• Zoom out (not sure how much this helps)

T

the_king_of_goatsAuthor

Known Participant

"• Use AM-code instead of DOM-code if possible (for example to replace the for-clause »for (var i = 0; i < layers.length; i++) {«)"

Interesting. Does AM code tend to run faster than DOM code?

"• Hide the Panels"

I've heard this one but never thought to try it. I might try to put Photoshop into some kind of "absolutely everything minimized//hidden/and it's full screen on the current tab only" mode to see if that actually does improve the speed. I'm not sure that it would, but if it takes time for the additional panels to load and render each time it opens and closes a document, I could imagine how it would give it a slight performance boost. I might integrate this, compare the execution times of a test, and see how it goes.

"Zoom out"

Honestly I don't see any good reason why this would help. Maybe by keeping it really zoomed out, it technically loads a smaller number of pixels to display, and is able to therefore run faster? I'm a little more skeptical of this one, but again, it's worth testing to compare the results.

c.pfaffenbichler

Community Expert

Interesting. Does AM code tend to run faster than DOM code?

Usually AM code runs faster than DOM code.

But there might be cases where it does not.

I might try to put Photoshop into some kind of "absolutely everything minimized//hidden/and it's full screen on the current tab only" mode to see if that actually does improve the speed.

I wonder if hiding Panels like Layers, Channels, Paths, Histogram, Properties, History, Info, Layer Comps that display document-specific information/previews would suffice to get the speed-increase.

Toolbar, Brushes, Styles, Actions etc. don’t need to change with a changing document so theoretically they might be irrelevant in this regard.

B

Barry Rudick

Inspiring

I might suggest that before running these kind of intensive scripts that the number of History steps be reduced to a bare minimum, like 2. This should reduce the time it takes for Photoshop to write History undos which will be written to the scratch drive if actual memory is saturated.

T

the_king_of_goatsAuthor

Known Participant

Yes, reducing History States before launching is a good call and actually something I was forced to implement at an earlier stage because this set of scripts would keep crashing Photoshop without it. I also programmatically wipe the History States periodically inside of the script as it runs. Not sure it technically helps much to do that, but I've noticed that with these two steps in place, it allows me to run enormous batches without causing the computer/Photoshop to slow down and run hot.

T

the_king_of_goatsAuthor

Known Participant

I'm wondering if there are some big-picture computer solutions. Maybe we can do something like, put Photoshop into some kind of like "maximum focus" mode where everything is minimized and ALL it does is execute the script with maximum efficiency? Or something similar in Windows 10 where I can say: "Until this script is fully done executing? Put EVERYTHING else on hold and dedicate the MAXIMUM amount of resources to getting this done?"

Like I don't need some Microsoft Edge update to run in the background, etc. I just need my computer's full set of resources entirely dedicated to running this one program with maximum efficiency. Any way I can set it up so my computer dedicates itself in that way?

Stephen Marsh

Community Expert

Is this an action or script?

What are the 13 steps?

Identify the bottlenecks at each of the 13 steps. Perhaps batch editing in ACR or LightRoom for specific steps may speed up the entire process, even if this means breaking up one large batch process into smaller steps. Look into other software which performs batch tasks more efficiently for one or more steps.

https://community.adobe.com/t5/photoshop-ecosystem-discussions/batch-action-crashes-after-7-077-files/m-p/10324770

T

the_king_of_goatsAuthor

Known Participant

There's a few more included but here are some of the key functions from the .jsx file:

// Function to check if a document is already flattened

function isDocumentFlattened(doc) {

var layers = doc.layers;

for (var i = 0; i < layers.length; i++) {

if (layers[i].typename !== "Layer") {

return false;

}

return true;

}

// Get the folder containing the images

var folderPath = "C:\\Users\\anton\\Pictures\\current image folder";

// Open each image in the folder

var folder = new Folder(folderPath);

var fileList = folder.getFiles(/\.(jpg|jpeg|png|gif|bmp)$/i);

for (var i = 0; i < fileList.length; i++) {

var file = fileList[i];

if (file instanceof File) {

// Open the document

var doc = app.open(file);

// Check if the document is already flattened

if (!isDocumentFlattened(doc)) {

// Flatten the document

doc.flatten();

// Save changes and close the document

doc.save();

doc.close(SaveOptions.DONOTSAVECHANGES);

} else {

// Close the document without saving changes

doc.close(SaveOptions.DONOTSAVECHANGES);

}

function runBatchAction(inputPath, outputPath, actionName, actionSet, wildcard) {

wildcard = wildcard || /\.(jpg|png)$/i;

var files = new Folder(inputPath).getFiles(function(file) { return wildcard.test(file.name) });

// https://theiviaxx.github.io/photoshop-docs/Photoshop/BatchOptions.html

var options = new BatchOptions();

options.destination = BatchDestinationType.FOLDER;

options.destinationFolder = new Folder(outputPath);

options.overrideOpen = false;

options.overrideSave = true;

// https://theiviaxx.github.io/photoshop-docs/Photoshop/FileNamingType.html

options.fileNaming = [FileNamingType.DOCUMENTNAMEMIXED, FileNamingType.EXTENSIONLOWER];

app.batch(files, actionName, actionSet, options);

// After batch processing, iterate over the files and replace dashes with spaces

var outputFolder = new Folder(outputPath);

var outputFiles = outputFolder.getFiles();

for (var i = 0; i < outputFiles.length; i++) {

var outputFile = outputFiles[i];

if (outputFile.name.indexOf('-') !== -1) {

var newFileName = outputFile.name.replace(/-/g, ' ');

outputFile.rename(newFileName);

}

function SmartObjectReplacementProduct(PhotoshopFilepathToUse) {

var filePath = PhotoshopFilepathToUse;

var fileRef = new File(filePath);

var docRef = app.open(fileRef);

BatchReplaceSmartObject(CanvasProductImages);

docRef.close(SaveOptions.DONOTSAVECHANGES);

}

function SmartObjectReplacementRoom(PhotoshopFilepathToUse) {

var filePath = PhotoshopFilepathToUse;

var fileRef = new File(filePath);

var docRef = app.open(fileRef);

BatchReplaceSmartObject(CanvasRoomImages);

docRef.close(SaveOptions.DONOTSAVECHANGES);

}

function BatchReplaceSmartObject(ImageFolderToUse) {

if (app.documents.length > 0) {

var myDocument = app.activeDocument;

var theName = myDocument.name.match(/(.*)\.[^\.]+$/)[1];

var thePath = myDocument.path;

var theLayer = myDocument.activeLayer;

// JPG Options

var jpgSaveOptions = new JPEGSaveOptions();

jpgSaveOptions.embedColorProfile = true;

jpgSaveOptions.formatOptions = FormatOptions.STANDARDBASELINE;

jpgSaveOptions.matte = MatteType.NONE;

jpgSaveOptions.quality = 8;

// Check if layer is SmartObject

if (theLayer.kind != "LayerKind.SMARTOBJECT") {

alert("Selected layer is not a smart object");

} else {

// Select Files

var theFiles = new Folder(ImageFolderToUse).getFiles(getFiles);

if (theFiles) {

for (var m = 0; m < theFiles.length; m++) {

// Replace SmartObject

theLayer = replaceContents(theFiles[m], theLayer);

var theNewName = theFiles[m].name.match(/(.*)\.[^\.]+$/)[1];

// Save JPG

myDocument.saveAs((new File(thePath + "/" + theName + "_" + theNewName + ".jpg")), jpgSaveOptions, true, Extension.LOWERCASE);

// Close the processed document to release memory

theFiles[m].close(SaveOptions.DONOTSAVECHANGES); // this line apparently doesn't actually do anything

// Purge all caches to free up memory

app.purge(PurgeTarget.ALLCACHES); // not sure all 4 are needed, just doing it to be thorough

app.purge(PurgeTarget.CLIPBOARDCACHE);

app.purge(PurgeTarget.HISTORYCACHES);

app.purge(PurgeTarget.UNDOCACHES);

}

// Get PSDs, TIFs, and JPGs from files

function getFiles(theFile) {

if (theFile.name.match(/\.(psd|tif|jpg)$/i) != null || theFile.constructor.name == "Folder") {

return true;

}

// Replace SmartObject Contents

function replaceContents(newFile, theSO) {

app.activeDocument.activeLayer = theSO;

// =======================================================

var idplacedLayerReplaceContents = stringIDToTypeID("placedLayerReplaceContents");

var desc3 = new ActionDescriptor();

var idnull = charIDToTypeID("null");

desc3.putPath(idnull, new File(newFile));

var idPgNm = charIDToTypeID("PgNm");

desc3.putInteger(idPgNm, 1);

executeAction(idplacedLayerReplaceContents, desc3, DialogModes.NO);

return app.activeDocument.activeLayer;

}

T

the_king_of_goatsAuthor

Known Participant

I did just realize in looking at this that I could combine two steps to decrease the runtime. The previous step opens each image file and performs a specified Photoshop edit on it. At that step I could just make the final step flatten the image. Then I won't have to run a whole separate batch where I open all images again to flatten then save them again. I'll just add one more step while already opening/saving them the first time around.

I also do another set of batches at the very end, where AFTER doing the smart-object replacement? I again open all images, then save them as a smaller compressed version. I see zero reason why I couldn't just include that specified save operation INSIDE of the code that batch-replaces the smart objects then saves each image as a JPEG. Since opening/saving files seems to be a pretty "expensive" operation in terms of runtime? This SHOULD help to streamline the code.

Implemented these changes, tested the scripts and here are the results:

ORIGINAL VERSION: 360 seconds
OPTIMIZED VERSION: 197 seconds
ORIGINAL VERSION = 1.8x MORE RUNTIME for identical end-results

In other words, this optimized version is almost 2x faster.

Sign up

To post, reply, or follow discussions, please sign in with your Adobe ID.

Sign in to Adobe Community

To post, reply, or follow discussions, please sign in with your Adobe ID.

Scanning file for viruses.

This file cannot be downloaded