Batch processing mutiple set of images as *Layers*

So, did either of those two scripts help?

EDIT: Another option here for sets of 3, it is easy enough to change it for sets of 10, however it is really slow compared to my script above as it uses the load files into stack script.

https://www.photoshopgurus.com/forum/threads/loading-all-images-in-a-folder-into-groups-of-3-is-it-possible.64634/

Here is a different approach, I have modified a script created for working on pairs of images into one that works on sets of ten images.

This script will only process a single top-level folder, so you would need a root-level folder of 100 images, not a root-level folder containing 10 sub-folders of 10 images each.

All you need to do is point it at a source folder and it will create layered TIFF versions with layers in stacks of 10. There is no error checking to ensure that the source folder contains multiples of 10 images. There is placeholder code to run an action from the actions panel before saving each layered file. The TIFF saving options can be swapped out for a different file format. The code could be optimised, I'm just a newb at scripting so it is a bit rough but it does the job. I have tried to comment the code at key points to explain what is taking place. Hope this helps!

/*

Combine images into 10 layers.jsx

by Stephen Marsh - 2020

https://community.adobe.com/t5/photoshop/batch-processing-mutiple-set-of-images-as-layers/m-p/11714886

Code based on the following topic thread:
https://community.adobe.com/t5/photoshop/open-photos-with-same-filename-as-layers/td-p/11515954

NOTE:
* No Files should be open.
* There is no error checking, the input folder should contain even quantities of 10 alphabetically sorting images.
* It is assumed that all files contain only a single image layer (flat or layered).
* It is also assumed that all files have the same pixel width, height and resolution.

*/

#target photoshop

/* Start Open Document Error Check - Part A: If */

if (app.documents.length === 0) {

    (function () {

        var restoreDialogMode = app.displayDialogs;
        app.displayDialogs = DialogModes.NO;

        inputFolder = Folder.selectDialog("Please select the folder with multiples of 10 alphabetically sorting files:");
        if (inputFolder === null) return;
        var newPath = Folder(decodeURI(inputFolder + "/Combined")); // Create sub-dir 
        if (!newPath.exists) newPath.create();
        var fileList = inputFolder.getFiles(/\.(jpg|jpeg|tif|tiff|png|psd)$/i); // Limit file format input
        fileList.sort(); // Force alpha-numeric list sort, to reverse the sort order use .sort.reverse();

        var inputCount = fileList.length;
        var cancelScript = confirm(inputCount + " input files stacked into sets of 10 will produce " + inputCount / 10 + " layered files. Press 'Yes' to continue or 'No' to cancel.");
        // Test if no returns false, then terminate the script
        if (cancelScript === false) {
            alert('Script cancelled!');
            return;
        }

        while (fileList.length) {
            for (var a = 0; a < 10; a++) { // Loop through 10 images
                try {
                    app.open(fileList.pop());
                } catch (e) { }
            }

            // Call the function named: processFiles
            processFiles();
        }

        alert("Files saved to '" + inputFolder + "/Combined'");

        function processFiles() {
            try {
                var Name = app.documents[0].name.replace(/\.[^\.]+$/, ''); // Remove file extension

                /* There must be a better way, however, this was the quickest way to modify the existing script from 2 to 10 layers... */

                // Document 2 to Document 1
                app.activeDocument = documents[1];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 3 to Document 1
                app.activeDocument = documents[2];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 4 to Document 1
                app.activeDocument = documents[3];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 5 to Document 1
                app.activeDocument = documents[4];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 6 to Document 1
                app.activeDocument = documents[5];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 7 to Document 1
                app.activeDocument = documents[6];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 8 to Document 1
                app.activeDocument = documents[7];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 9 to Document 1
                app.activeDocument = documents[8];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Document 10 to Document 1
                app.activeDocument = documents[9];
                app.activeDocument.activeLayer.duplicate(documents[0]);
                // Set Document 1 as the target for further processing
                app.activeDocument = documents[0];

                /* There should now be 10 layers! Do something else, such as run an action? */
                // If so, uncomment the line below and change the action and action set as required...
                //app.doAction("MyAction", "MyActionSet"); 

                app.displayDialogs = restoreDialogMode;

            } catch (e) { }

            var saveFile = File(newPath + "/" + Name + "_Combined" + ".tif");

            // Call the function named: saveTIFF
            saveTIFF(saveFile);

            // Close all open docs without saving
            while (app.documents.length) {
                app.activeDocument.close(SaveOptions.DONOTSAVECHANGES);
            }
        }

        function saveTIFF(saveFile) {
            tiffSaveOptions = new TiffSaveOptions();
            tiffSaveOptions.embedColorProfile = true;
            tiffSaveOptions.byteOrder = ByteOrder.IBM;
            tiffSaveOptions.transparency = true;
            tiffSaveOptions.layers = true;
            tiffSaveOptions.layerCompression = LayerCompression.ZIP;
            tiffSaveOptions.interleaveChannels = true;
            tiffSaveOptions.alphaChannels = true;
            tiffSaveOptions.annotations = true;
            tiffSaveOptions.spotColors = true;
            tiffSaveOptions.saveImagePyramid = false;
            tiffSaveOptions.imageCompression = TIFFEncoding.TIFFLZW; // NONE | JPEG | TIFFLZW | TIFFZIP

            app.activeDocument.saveAs(saveFile, tiffSaveOptions, true, Extension.LOWERCASE);
        }

    })();
}

/* Finish Open Document Error Check - Part A: If */

/* Start Open Document Error Check - Part B: Else */

else {

    alert('Please close all open documents before running this script!');
}

/* Finish Open Document Error Check - Part B: Else */

I have made very minor adjustments to one of JJMack's scripts here (forcing alpha-numeric sorting and some other options around line 587 or so):

https://github.com/MarshySwamp/Layer-Stack-N-Number-of-Files-Filename-as-Top-Layer

You will need both scripts in the same location, as the main script requires the prefs script.

You will need to create a template file the same size as the input images. The template file has to be flattened with a background layer, it also has to have 10 white alpha channels named:

Image 1

Image 2

...

Image 10

That is it!

PSD files are saved as the default output method, you will end up with 10 layers per combined PSD image. Note: each layer is a smart object (you may need to modify the script or adjust your layer processing action). You may also wish to remove the redundant alpha channel from the resulting output files.

At this point, you would need to process each layered file with your action as a second, separate process (Batch, Image Processor, Image Processor Pro, Picture Processor etc).

If you dig into JJMack's code, you could of course add some code to process the layers, so that a second bulk processing step is not required. I'll leave that up to you.

If there is still interest, I have a couple of options that may fast-track the process.

»Is there really no way around this?«

The obvious solution would be abandoning Batch and creating (or using) a proper Scripting. 

How good are you with JavaScript?