#!/bin/bash
 
 STEPS=70
 
 OUTPUTDIR=o
 TMPTEX=grafik2slits.tex
 
 PDF=`find i/pdf -name "*.pdf" | shuf -n 1`
 PDF="i/pdf/var/A4_referenzblatt.pdf"
 
 IDENTIFY=`identify $PDF`
 PDFWIDTH=`echo $IDENTIFY | \
           cut -d " " -f 3 | \
           head -1 | cut -d "x" -f 1`
 PDFHEIGHT=`echo $IDENTIFY | \
            cut -d " " -f 3 | \
            head -1 | cut -d "x" -f 2`
 
 STEPWIDTH=`expr $PDFWIDTH \/ $STEPS`
 
 VERTICALOFFSET=`expr $STEPS + \`expr $STEPS \/ 4 \``
 
 
  echo "\documentclass[9pt]{scrbook}                  " >  $TMPTEX
  echo "\usepackage{pdfpages}                         " >> $TMPTEX
  echo "\usepackage{geometry}                         " >> $TMPTEX
  echo "\geometry{paperwidth=595pt,paperheight=842pt} " >> $TMPTEX
  echo "\usepackage[pdftex]{epsfig}                   " >> $TMPTEX
 
  echo "\setlength{\unitlength}{"$STEPWIDTH"pt}       " >> $TMPTEX
  echo "\setlength\topmargin{-0.1in}                  " >> $TMPTEX
  echo "\setlength\oddsidemargin{-1.2in}              " >> $TMPTEX
  echo "\setlength\textwidth{\paperwidth}             " >> $TMPTEX
 
  echo "\newcommand{                                  " >> $TMPTEX
  echo "\graphic}[6]{                                 " >> $TMPTEX
  echo "\includegraphics[viewport=#2 #3 #4 #5,clip,   " >> $TMPTEX
  echo "height=\paperheight]{#1}}                     " >> $TMPTEX
 
  echo "\begin{document}                              " >> $TMPTEX
  echo "                                              " >> $TMPTEX
 
  # ------------------------------------------------------- #
    echo "\\begin{picture}(0,0)                " >> $TMPTEX
 
    CNT=0
    while [ $CNT -lt $STEPS ]
     do
        LEFT=`expr $CNT \* $STEPWIDTH`
        RIGHT=`expr $STEPWIDTH + $LEFT`
 
        echo  "\put("$CNT",-"$VERTICALOFFSET"){" >> $TMPTEX
        echo  "\graphic{"$PDF"}{"$LEFT"}{0}    " >> $TMPTEX
        echo  "{"$RIGHT"}{"$PDFHEIGHT"}}       " >> $TMPTEX
 
        CNT=`expr $CNT + 1`
    done
 
   echo "\end{picture}                         " >> $TMPTEX
  # ------------------------------------------------------- #
 
  echo "\end{document}                                " >> $TMPTEX
 
 pdflatex -output-directory $OUTPUTDIR $TMPTEX
 
 rm $TMPTEX
 
exit 0;

LaTeX: \newcommand

A custom LaTeX command for the inclusion of the graphics is defined:

\newcommand{\graphic}[6]{
            \includegraphics[viewport=#2 #3 #4 #5,clip,
            height=\paperheight]{#1}
            }

Bash supports a surprising number of string manipulation operations. Unfortunately, these tools lack a unified focus. Some are a subset of parameter substitution, and others fall under the functionality of the UNIX expr command. This results in inconsistent command syntax and overlap of functionality, not to mention confusion. *

This is a short explanation of Bash’s substition mechanisms I use most frequently. For further information visit the Advanced Bash-Scripting Guide. The construct ${VARIABLE%pattern} removes the shortest possible suffix of a variable string. This is most commonly used to remove a filename extension from a variable. As pattern we use .* = a dot (.) plus a possible number of characters.

:~$ VARIABLE=/home/lisl/dummy.txt
 
:~$ echo $VARIABLE
/home/lisl/dummy.txt
 
:~$ echo ${VARIABLE%.*}
/home/lisl/dummy

While the construct ${VARIABLE%.*} removes the shortest possible suffix of the variable string, the construct ${VARIABLE%%.*} (=2 times %!) removes the longest possible suffix:

:~$ ONEDOT=/home/lisl/dummy.txt
:~$ TWODOT=/home/lisl/.hidden/dummy.txt
 
:~$ echo ${ONEDOT%.*}
/home/lisl/dummy
 
:~$ echo ${ONEDOT%%.*}
/home/lisl/dummy

Within this example, we get the same output, because the string contains only one dot and therefore the longest and the shortest possible suffix is actually the same. If the string contains more than one dot, you will see the difference:

:~$ echo ${TWODOT%.*}
/home/lisl/.hidden/dummy
 
:~$ echo ${TWODOT%%.*}
/home/lisl/

To remove the prefix instead of the suffix you use # instead of %.

:~$ echo ${TWODOT#*.}
hidden/dummy.txt
 
:~$ echo ${TWODOT##*.}
txt

Best way to start is just by trying out. In-depth documentation here.

pdfpages

A simple solution to combine multiple pdf files is to use LaTeX respectively the pdfpages package.

With this code you can layout pdf pages on a page according to some parametres. You need a working LaTeX installation, e.g. texlive on debian or ubuntu. You type the code in a plain text file (ending .tex) and compile it with pdflatex.

\documentclass[9pt]{scrbook}          
\usepackage{pdfpages}                 
\begin{document}                                      
\includepdfmerge                      
[nup=10x10,pages=1,scale=.9,                            
trim=26pt 26pt 26pt 26pt,clip,        
delta=0pt 0pt,offset=0 0]                  
{pdf1.pdf,pdf2.pdf.pdf3.pf}
\end{document}

Instead of typing the code by one might use a script:

# ======================================================= #
# ------------------------------------------------------- #
# CREATE LaTeX CONTROL FILE
# ------------------------------------------------------- #
 
LISTTOTAKE=$TMPDIR/polyline.list
TMPTEX=tmp.tex
 
echo "\documentclass[9pt]{scrbook}          " >  $TMPTEX
echo "\usepackage{pdfpages}                 " >> $TMPTEX
echo "\begin{document}                      " >> $TMPTEX
echo "                                      " >> $TMPTEX
echo "\includepdfmerge                      " >> $TMPTEX
echo "[                                     " >> $TMPTEX
echo "nup=10x10,pages=1                     " >> $TMPTEX
echo "scale=.9,                             " >> $TMPTEX
echo "trim=26pt 26pt 26pt 26pt,clip,        " >> $TMPTEX
echo "delta=0pt 0pt,offset=0 0              " >> $TMPTEX
echo "]                                     " >> $TMPTEX
echo "{                                     " >> $TMPTEX
 
COUNT=1
HOWMANYPDFS=`cat $LISTTOTAKE | wc -l`
 
# --------------------------------- #
for PDF in `cat $LISTTOTAKE`
 do
   KOMMA=","
   if [ $COUNT -eq $HOWMANYPDFS ];
   then
        KOMMA=""
   fi
   echo ${PDF}${KOMMA} >> $TMPTEX
   COUNT=`expr $COUNT + 1`
done
# --------------------------------- #
 
echo "}                                     " >> $TMPTEX
echo "\end{document}                        " >> $TMPTEX
 
# ======================================================= #
# ------------------------------------------------------- #
# RENDER LaTeX FILE
# ------------------------------------------------------- #
 
pdflatex -output-directory $OUTPUTDIR $TMPTEX

pdftkloop

A very simple solution to produce a layered pdf file is pdftk. pdftk offers the functionality to place a pdf as background into another. Inside a loop the output of pdftk becomes the background for the next round. This way we get a staple of pdf files.

BEFORE=$TMPDIR/before.pdf
cp `cat $LIST | shuf -n 1` $BEFORE
 
 
for PDF in `cat $LIST`
  do
     pdftk $PDF background $BEFORE output $TMPDIR/out.pdf    
     cp $TMPDIR/out.pdf $BEFORE
done

Lists are the most simple example for a control file. For the creation of lists I would describe two different approaches: creation and analysis .

creation

INPUTDIR=i/pdf/alphabets
LIST=$TMPDIR/sentence.list
 
for LETTER in H E L L O W O R L D
 do
   find ${INPUTDIR} -name "$LETTER*.pdf" |\ 
   shuf -n 1 >> $LIST
done

Within this loop I want to find a matching pdf file for every letter in the sentence HELLO WORLD.
The pdf files were created in advance, all letters in different fonts.

The result:

i/pdf/alphabets/_Nimbus_Sans_L_/H.pdf
i/pdf/alphabets/_eufm10________/E.pdf
i/pdf/alphabets/_eufm10________/L.pdf
i/pdf/alphabets/_Courier_New___/L.pdf
i/pdf/alphabets/_Nimbus_Sans_L_/O.pdf
i/pdf/alphabets/_Nimbus_Sans_L_/W.pdf
i/pdf/alphabets/_Webdings______/O.pdf
i/pdf/alphabets/_Nimbus_Sans_L_/R.pdf
i/pdf/alphabets/_Webdings______/L.pdf
i/pdf/alphabets/_Webdings______/D.pdf

analysis

INPUTDIR=i/pdf/words/_Nimbus_Sans_L_/
LIST=$TMPDIR/alphabet.list
 
ls -rS ${INPUTDIR}/*.pdf > $LIST

ls -S is the command to list files in a order according to their file size.

The selected files are random words stored as pdf files. The idea is to get a sorting dependent on the complexity of the words. The file size is connected to the amount of vector path information. A letter with a complex form produces a bigger file size. The filesize of a word is therefore dependent on number and complexity of its letters.

The result:

i/pdf/words/_Nimbus_Sans_L_/lollopy.pdf
i/pdf/words/_Nimbus_Sans_L_/sculpt.pdf
i/pdf/words/_Nimbus_Sans_L_/dovelike.pdf
i/pdf/words/_Nimbus_Sans_L_/pubes.pdf
i/pdf/words/_Nimbus_Sans_L_/Clerus.pdf
i/pdf/words/_Nimbus_Sans_L_/canelo.pdf
i/pdf/words/_Nimbus_Sans_L_/Mezentius.pdf
i/pdf/words/_Nimbus_Sans_L_/denounce.pdf
i/pdf/words/_Nimbus_Sans_L_/tiptoppish.pdf
i/pdf/words/_Nimbus_Sans_L_/focometry.pdf
i/pdf/words/_Nimbus_Sans_L_/ungeneric.pdf
i/pdf/words/_Nimbus_Sans_L_/periocular.pdf
i/pdf/words/_Nimbus_Sans_L_/gynarchic.pdf
i/pdf/words/_Nimbus_Sans_L_/polycythemic.pdf
i/pdf/words/_Nimbus_Sans_L_/untrinitarian.pdf
i/pdf/words/_Nimbus_Sans_L_/scaldweed.pdf
i/pdf/words/_Nimbus_Sans_L_/enchondrosis.pdf
i/pdf/words/_Nimbus_Sans_L_/unscathedly.pdf
i/pdf/words/_Nimbus_Sans_L_/phlebotomical.pdf
i/pdf/words/_Nimbus_Sans_L_/transferred.pdf
i/pdf/words/_Nimbus_Sans_L_/photophysical.pdf
i/pdf/words/_Nimbus_Sans_L_/balaenoidean.pdf
i/pdf/words/_Nimbus_Sans_L_/hyperterrestrial.pdf

The visual results

The lists are used to generate pdf files in the next step.

On the commandline most programs follow the simple principle of creating and modifying plain text. To make this approach extremly productive the Bash offers some mechanisms.

The so-called pipe character (|) acts like a plug to send the output of one program to the input of another. This way way you can easily plug together toolchains, e.g.

`ls | rev` 

combines the list and revert command.
To direct the output of a program into a file, instead of another program, you can use the > character.

ls *.* > somefile.txt

A single > writes a new file, while a double >> appends to a file (if it exists).

Variables are another feature. The value of a variable may be accessed after defining through putting a $ in front of your variable name:

HELLO="Hello World"
echo $HELLO

With backticks you can capsule the output of a program, this means the result of the command inside the backticks will generate command line text. For example: if ls *.* | head -1 = some.txt, then

cat `ls *.* | head -1` 

is the same as

cat some.txt 

This is especially useful to define variables.

FILE=`ls *.* | head -1`

Loops

Since the Bash is not only a user interface, but a fairly powerful programming language, it offers loops, one of the most basic and powerful principles of computer programming.

for–loops can be executed on a space separated list of ‘words’. The loop-definition may be saved in a file or entered directly on the commandline: for LETTER in A B; do echo $LETTER ;done
A for–loop may of course be combined with a command capsuled in backticks.

for FILE in `ls *.*`; do echo $FILE; done

A while–loop runs while a certain precondition is true:

while [ 1 -lt 2 ]
 do
     echo "true"
done

-lt means less than.

Also available:
-eq = equal
-le = less equal
-gt = greater than
-ge = greater equal

This loop will basically run forever, since 1 will always be less than 2.
Combined with a variable and upcounting inside backticks,

COUNT=0
while [ $COUNT -le 10 ]
 do
    echo $COUNT
    COUNT=`expr $COUNT + 1`
done

the loop will stop.

You find a good introduction at floss manuals. For a complete introduction check the Advanced Bash Scripting Guide.
For inspiration read $(echo echo) echo $(echo): Command Line Poetics