Photoshop Script: layout images like flickr - photoshop

Question

I am looking for a script that would open a given number of images with different aspect ratios and layout them all in a single document like the flickr gallery. Something as seen in this page: http://martin-oehm.de/data/layout.html
Is there any script/plugin out there that can do this? The purpose is just to create a reference file with all the images instead of having several images floating around.
Thank you

Answer 1

The fact that you have had no answers in 10 weeks should tell you that Photoshop is maybe not the best/easiest place to do this.... so, I made the following script that does it pretty well outside of Photoshop.
It assumes you have OSX or Linux to run a bash script and it uses ImageMagick to actually do the image processing.
#!/bin/bash
################################################################################
# layout
# Mark Setchell
#
# Layout all images in current directory onto contact sheet. Algorithm is crude
# but fairly effective as follows:
#
# Create temporary workspace
# Resize all images to standard HEIGHT into workspace saving names & new widths
# row=0
# Repeat till there are no images
# Repeat till row is full
# Append widest image that will fit to this row
# End repeat
# Append this row to output contact sheet
# row++
# End repeat
################################################################################
WORKSPACE=layout-$$.d
HEIGHT=300
WIDTH=2000
PAD=50
shopt -s nullglob
shopt -s nocaseglob
# Declare our arrays
declare -a names
declare -a width
declare -a indices
################################################################################
# Returns the number of images remaining still to be laid out
################################################################################
NumRemaining(){
local result=0
local z
for ((z=0;z<${#width[#]};z++)) do
if [ ${width[z]} -gt 0 ]; then
((result++))
fi
done
echo $result
}
################################################################################
# Returns index of widest image that fits in specified width
################################################################################
BestFitting(){
local limit=$1
local index=-1
local widest=0
local z
local t
for ((z=0;z<${#width[#]};z++)) do
t=${width[z]}
if [[ $t -gt 0 && $t -le $limit && $t -gt $widest ]]; then
widest=$t
index=$z
fi
done
echo $index
}
mkdir $WORKSPACE 2> /dev/null
n=0
for f in *.jpg *.png *.gif *.psd; do
# Save name
names[n]=$f
# Extract file extension and basic name, because we want to add "[0]" to end of PSD files
ext="${f##*.}"
base="${f%.*}"
echo $ext | tr "[A-Z]" "[a-z]" | grep -q "psd$"
if [ $? -eq 0 ]; then
convert "$f[0]" -resize x${HEIGHT} $WORKSPACE/${n}.jpg
else
convert "$f" -resize x${HEIGHT} $WORKSPACE/${n}.jpg
fi
# Get width of the resized file and save
width[n]=$(identify -format "%w" $WORKSPACE/${n}.jpg)
echo DEBUG: Index: $n is file: $f thumbnailed to width: ${width[n]}
((n++))
done
echo DEBUG: All images added
echo
cd "$WORKSPACE"
row=0
while [ $(NumRemaining) -gt 0 ]; do
echo DEBUG: Processing row $row, images left $(NumRemaining)
remaining=$WIDTH # new row, we have the full width to play with
cumwidth=0 # cumulative width of images in this row
i=0 # clear array of image indices in this row
while [ $remaining -gt 0 ]; do
best=$(BestFitting $remaining)
if [ $best -lt 0 ]; then break; fi
indices[i]=$best # add this image's index to the indices of images in this row
w=${width[best]}
((cumwidth=cumwidth+w))
((remaining=WIDTH-cumwidth-i*PAD)) # decrease remaining space on this line
width[best]=-1 # effectively remove image from list
((i++))
echo DEBUG: Adding index: $best, width=$w, cumwidth=$cumwidth, remaining=$remaining
done
if [ $i -lt 1 ]; then break; fi # break if no images in this row
PADWIDTH=$PAD
if [ $i -gt 1 ]; then ((PADWIDTH=(WIDTH-cumwidth)/(i-1))); fi
echo $(NumRemaining)
echo $i
if [ $(NumRemaining) -eq 0 ]; then PADWIDTH=$PAD; fi # don't stretch last row
echo DEBUG: Padding between images: $PADWIDTH
ROWFILE="row-${row}.png"
THIS="${indices[0]}.jpg"
# Start row with left pad
convert -size ${PAD}x${HEIGHT}! xc:white $ROWFILE
for ((z=0;z<$i;z++)); do
if [ $z -gt 0 ]; then
# Add pad to right before appending image
convert $ROWFILE -size ${PADWIDTH}x${HEIGHT}! xc:white +append $ROWFILE
fi
THIS="${indices[z]}.jpg"
convert $ROWFILE $THIS +append $ROWFILE
done
# End row with right pad
convert $ROWFILE -size ${PAD}x${HEIGHT}! xc:white +append $ROWFILE
((row++))
echo DEBUG: End of row
echo
done
# Having generated all rows, append them all together one below the next
((tmp=WIDTH+2*PAD))
convert -size ${tmp}x${PAD} xc:white result.png
for r in row*.png; do
convert result.png $r -size ${tmp}x${PAD}! xc:white -append result.png
done
open result.png
Depending on the files in your input directory (obviously), it produces output like this:
with debug information in your Terminal window as it goes like this:
DEBUG: Index: 0 is file: 1.png thumbnailed to width: 800
DEBUG: Index: 1 is file: 10.png thumbnailed to width: 236
DEBUG: Index: 2 is file: 11.png thumbnailed to width: 236
DEBUG: Index: 3 is file: 12.png thumbnailed to width: 360
DEBUG: Index: 4 is file: 2.png thumbnailed to width: 480
DEBUG: Index: 5 is file: 3.png thumbnailed to width: 240
DEBUG: Index: 6 is file: 4.png thumbnailed to width: 218
DEBUG: Index: 7 is file: 5.png thumbnailed to width: 375
DEBUG: Index: 8 is file: 6.png thumbnailed to width: 1125
DEBUG: Index: 9 is file: 7.png thumbnailed to width: 1226
DEBUG: Index: 10 is file: 8.png thumbnailed to width: 450
DEBUG: Index: 11 is file: 9.png thumbnailed to width: 300
DEBUG: Index: 12 is file: a.png thumbnailed to width: 400
DEBUG: All images added
DEBUG: Processing row 0, images left 13
DEBUG: Adding index: 9, width=1226, cumwidth=1226, remaining=774
DEBUG: Adding index: 4, width=480, cumwidth=1706, remaining=244
DEBUG: Adding index: 5, width=240, cumwidth=1946, remaining=-46
DEBUG: Padding between images: 27
DEBUG: End of row
DEBUG: Processing row 1, images left 10
DEBUG: Adding index: 8, width=1125, cumwidth=1125, remaining=875
DEBUG: Adding index: 0, width=800, cumwidth=1925, remaining=25
DEBUG: Padding between images: 75
DEBUG: End of row
DEBUG: Processing row 2, images left 8
DEBUG: Adding index: 10, width=450, cumwidth=450, remaining=1550
DEBUG: Adding index: 12, width=400, cumwidth=850, remaining=1100
DEBUG: Adding index: 7, width=375, cumwidth=1225, remaining=675
DEBUG: Adding index: 3, width=360, cumwidth=1585, remaining=265
DEBUG: Adding index: 1, width=236, cumwidth=1821, remaining=-21
DEBUG: Padding between images: 44
DEBUG: End of row
DEBUG: Processing row 3, images left 3
DEBUG: Adding index: 11, width=300, cumwidth=300, remaining=1700
DEBUG: Adding index: 2, width=236, cumwidth=536, remaining=1414
DEBUG: Adding index: 6, width=218, cumwidth=754, remaining=1146
DEBUG: Padding between images: 623
DEBUG: End of row
Upon reflection, the output could maybe be improved by reversing odd-numbered rows so that the largest image on each line is on the left one time and on the right the next time - it is a simple change but I don't want to over-complicate the code. Basically, you would reverse the order of the array indices[] every second time you fall out of the row-assembling loop.
Here are some maybe useful links:
Google+ algorithm
flickr algorithm in jQuery
I presume Photoshop's built-in File->Automate->Contact Sheet II is inadequate for your purposes...