Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

Pdfjam, imposition, livret, modification de pdf

Ouessant

--edit
Pour éviter à ceux qui seraient intéressés de parcourir toute la discussion qui suit, qui se rapproche d'ailleurs plutôt d'un monologue, voici ce que fait le script dont il s'agit.

Ce script fait de *l'imposition (Lien pour une explication de l'imposition en imprimerie ; plus technique):
- en un seul livret [pdfbook].
- en 4 feuilles par pages, en cahier d'autant de pages que voulues [pdfbook].
- en 8 feuilles par pages,
* en 8 pages par cahier
* ou en 16
- en 16 feuilles par pages, cahiers de 16 pages.
* Surtout ce script gère les décalages dus à l'épaisseur du papier et au pliage.
J'appelle gouttière cette gestion du décalage dû à l'épaisseur du papier. D'où l'option -g. Cette option prend comme valeur le décalage vers l'éxtérieur des pages extérieures des cahiers. Ainsi pour un cahier de 8 pages, les pages 1 et 8 sont décalées de G, 2 et 7 de 0,66 x G , 3 et 6 de 0,33 x G , 4 et 5 de 0 x G.
* on peut de plus décaler toutes les pages en hauteurs ou bien vers l'extérieur (vers la droite pour les pages impaires, l'inverse pour les pages paires, la page 1 étant une page droite).
* en utilisant l'option -m 'LISTE' le script ne fait plus d'imposition mais déplace les pages indiquées verticalement ou horizontalement.

L'option -h affiche une description des options. Si c'est pas clair, faîtes m'en part.

Pour les décalages il faut donner un nombre, qui correspond dans le script à des points (pt ; 1 point = 0,3759mm).
Le script n'ajoute aucunes autres modifications. Il faut donc prévoir ses marges et ses traits de coupe. À moins que quelqu'un ne veuille l'ajouter...
Côté qualité ce script utilise pdfjam et donc le résultat est de la même qualité que ce programme qui utilise lui-même TeX. Ayant une immense confiance en la qualité de TeX, je crois que le résultat ne peut-être que de qualité.
Côté programme ne vous étonnez pas de trouver des hérésies. Je suis prêt à tout avouer, reconnaître, corriger... Je suis autodidacte dans le domaine et c'est mon premier et sans doute mon dernier script de plus de 20 lignes. Corrigez donc tout ce que vous voulez. Pourquoi n'ai-je pas choisi tel ou tel langage ?... C'est celui que j'avais sous la main et ça marche sur toutes les machines linux.

Voici le script dans sa dernière version (31/03/2015):
(Installation de pdfjam requise : sudo apt-get install pdfjam).
Mais avant, pour ceux qui n'ont jamais exécuté (promis c'est pas violent!) de script :
- créer un fichier texte vierge et le nommer uniquement : pdflivre.sh
- copier tout le texte du script ci-dessous dans ce fichier, le fermer en l'enregistrant.
- clic droit sur le fichier > Propriétés > Permissions > Cocher "Autoriser ce fichier à s'exécuter comme un programme".
- ouvrir un terminal, attraper le fichier et l'y faire glisser. Taper entrée, le message d'aide s'affiche.

En #5 des exemples.

#/bin/bash

# Ca semble très long mais :
# il y a une centaine de lignes pour l'aide et la définition des variables  1. Les variables
# une centaine de lignes de fonction dont l'une est un peu complexe         2. Les fonctions
# on reprend ensuite trois fois la même logique : 3 x 50                    3. Le script



################    AIDE
aide ()
{
	echo -e "
USAGE : pdflivre -i entrée.pdf [OPTIONS]\n
Manipulation de pdf utilisant pdfjam (TeX).
Imposition en livret ou en cahier, déplacement des pages, gouttière.\n
Seule la première option est obligatoire: par défaut imposition en 1
livret en 4 pages par feuille.
   -i FICHIER    FICHIER est un document pdf (format portrait pour
                     l'imposition).
   -o FICHIER    FICHIER est le document de sortie.
                       [Défaut : ~/pdflivre.pdf].
                       
   -f NPFEUILLE  NPFEUILLE est le nombre de pages par feuilles.
                     * 4 : 2 pages par face (utilise pdfbook).
                     * 8 
                     * 16                       [Defaut: 4]
   -c NPCAHIER   NPCAHIER est le nombre de pages par cahier.
                     * 8, 16, 32... pour 4 pages par feuilles,
                            [Défaut: un seul livret].
                     * de 8 [défaut] ou de 16 pour 8 pages par feuilles.
                     * non disponible pour 16.
   -d DELTAH    DELTAH est un nombre. Il permet de décaler toutes
                     les pages vers le haut d'autant de pt.
   -v DELTAV    Décalage les pages vers l'extérieur d'autant de pt.
   -g GOUTTIÈRE Toujours un nombre en point. C'est le décalage
                     vers l'extérieur des pages extérieures
                     des cahiers. Les autres pages sont décalées
                     proportionnelement. Ici les décimales ne sont
                     pas prises en compte : 1,95 -> 1 pt ...
                     Pour du papier 80g compter environ 1pt pour
                     2 feuilles. Autrement, prendre 10 feuilles, les
                     plier et mesurer le décalage.

pdflivre -i entrée.pdf -m 'LISTE'                     
   -m 'LISTE'   LISTE indique PAGE1,DeltaH,DeltaV:PAGE2,DeltaH...
                     Exemple : '10,5,-2:15,5,0' déplacera la page 10
                     de 5 pt vers la droite de -2 pt vers le haut
                     cad de 2 pt vers le bas ; puis la p 15 de 5pt
                     vers la droite.
                     Si cette option est utilisée l'imposition n'est
                     pas effectuée: il faut procéder en deux fois.
                     
   -s           Ne pas effacer le dossier temporaire /tmp/pdflivre.
   -h           Cette aide.
"
exit 0
}
####################




mkdir -p /tmp/pdflivre

##########################################################

#	1.                  Les variables

##########################################################

while getopts "i:o:c:f:d:v:g:m:sh" option ; do
 case $option in
   i) IN="$OPTARG";;
   o) OUT="$OPTARG";;
   c) NPCAHIER="$OPTARG";;
   f) NPFEUILLE="$OPTARG";;  
   d) DELTAG="$OPTARG";;              #	Décalage horizontal vers l'extérieur (pour toutes les pages) 
   v) DELTAV="$OPTARG";; 
   g) OFFSETG="$OPTARG";;              #	Offset (décalage vers l'extérieur des pages extérieures 
                                          #+	des cahiers, les intérieures sont décalées selon 
                                          #	une fonction linéaire)
   m) LISTEDELTA="$OPTARG";;
   s) NETTOYAGE=0;;
   h) aide ;;
   ?) echo "Option -$OPTARG inconnue" ; aide ;;
 esac
done

NPAGE=`pdfinfo "$IN" |grep "Pages:"|cut -c 17-`                  #   Nombre de page du pdf.						
dim='pt'
### On traite les cas d'absence d'option en donnant des valeurs par défaut sauf pour l'entrée.

if [ -z "$IN" ]; then
  aide
fi

if [ -z "$OUT" ]; then
   OUT=`echo ~/pdflivre.pdf`
fi

if [ -z "$NPFEUILLE" ]; then          #	Le nombre de page par feuille : peut-être 4 (pdfbook), 8 ou 16
    NPFEUILLE=4
fi

if [ -z "$NPCAHIER" ]; then           #	Nombre de page par cahier 
            # Il faut correctement définir $NPCAHIER car il sert au calcul de la gouttière:
   if [ "$NPFEUILLE" = 8 ]
   then NPCAHIER=8
   else    
	   let " NPCAHIER = 4*(($NPAGE +3)/4)"        #   On profite de ce que let ne connaisse
	   echo "NPCAHIER = $NPCAHIER"
	   LIVRET=1
	   echo 'LIVRET'                                   #+      pas les demi-mesure.
	fi
fi
          
if [ -z "$DELTAG" ]; then             #	Décalage horizontal vers l'extérieur (pour toutes les pages)
    DELTAG=0
fi 

if [ -z "$DELTAV" ]; then             #	Décalage vertical (pour toutes les pages)
    DELTAV=0
fi 

if [ -z "$OFFSETG" ]; then            #	Offset (décalage vers l'extérieur des pages extérieures 
    OFFSETG=0                          #+	des cahiers, les intérieures sont décalées selon 
fi                                      #	une fonction linéaire)


let " NPTOTAL = ((( "$NPAGE" -1)/ "$NPCAHIER")+1)*"$NPCAHIER" " #   Nombre final de page du pdf : premier multiple du nombre de cahier.
 							












##########################################################

#	2.                LES FONCTIONS

##########################################################





####### 	Pour faire joli et donner des nouvelles
message ()
{
echo -e "\n=============================\n$1" 
}






####### 	Fonction de dispersion des pages en autant de documents

dispersion ()
{
message 'FONCTION DE DISPERSION'
	#	Calcul de l'offset :
#		Pour les pages le plus à l'extérieur il faut tout l'offset. Exemple dans le cas de 8
#		pages par cahier : les pages 1 et 8, puis 9 et 16...
#		Tandis que l'offset doit être à 0 pour les pages intérieures. Ex : 4 et 5.
#		Dans notre exemple on va donc tacher de donner 3/3 d'offset aux pages 1 et 8,
#		2/3 aux 2 et 7, 1/3 aux 3 et 6, 0/3 aux 4 et 5.
#		y est ce 3 , x prend les valeurs de 3 à 0 puis 0 à 3 grâce à z qui le fait s'incrémenter ou se décrémenter... 
	let " y = ($NPCAHIER /2)-1 "
	x="$y"
	z=-1



###	La boucle de dispersion
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		
		#	Calcul de l'offset (Histoire x,y et z...
				
		let " DELTAH = $DELTAG + (($x* $OFFSETG)/$y) " 		# 	Le delta horizontal vaut le delta
															#+ 	general plus l'offset
		    if [ $i = 1 ]; then
		        i=0                                         # i est l'indicateur de sommet de cahier:
                                    #+  quand il vaut 1 $x doit rester sur 0 ou y une deuxième fois.
		      else
		        let " x = x + z "
				case $x in
					0|"$y") let " z = - $z " 
					        i=1 ;;
				esac
			fi
		    
		    
		#	Le décalage horizontal doit être négatif pour les pages impaires 
			#+	afin d'être toujours vers l'exterieur.
		let " n = 2* ($p /2) " 
				if [ $p -eq "$n" ]; then
					DELTA="-$DELTAH$dim $DELTAV$dim"
						
				else
					DELTA="$DELTAH$dim $DELTAV$dim" 
				fi
		
		#Tout est prêt.
			
		NOMPAGE="/tmp/pdflivre/$p.pdf"
		message " Export de la page $p sur $NPAGE\n Décalage vertical : $DELTAH pt\n Vers l'éxterieur  : $DELTAV pt" # Message
		pdfjam $IN $p --offset "$DELTA" --outfile $NOMPAGE
	done
# Fin de la fonction dispersion
}



####### Pour tourner les pages de la $liste de 180°

retournement ()         #   ATTENTION : la $liste est définie en son lieu car 
                        #+      propre à chaque imposition
{
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
	echo "$NOMPAGE"
	    let " POURCENT = (100 * $p) / $NPTOTAL "			# Un petit message
		message " Rotation des pages : $POURCENT %" 
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done
}

#



####### Pour rassembler les pages ainsi tournées

rassemblement ()
{
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done
output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output
}


### rassemblement mais en complétant avec des pages blanches jusqu'au nombre de pages du document final, multiple du nombre de cahier
rassemblement_complet ()
{
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done

while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output
}

#



nettoyage ()
{
if [ "$NETTOYAGE" = 0 ]; then
        message 'Les fichiers temporaires sont dans /tmp/pdflivre'
        exit 0 
  else
        rm -r /tmp/pdflivre
fi
}




##########################################################

#    3.             DECALAGE page par page    

##########################################################




if [ -z "$LISTEDELTA" ]; then
    debile=0
else

message 'DECALAGE PAGE PAR PAGE'

#   La boucle de dispersion mais avec DELTAH et DELTAV qui varient en fonction de $LISTEDELTA
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		DELTAH=0
		DELTAV=0
		    for l in `seq 1 "$NPAGE"` ; 
		    do
		        PAGE=`echo "$LISTEDELTA" | cut -d":" -f $l | cut -d"," -f1`
		        if [ -z $PAGE ]; then # Là y a un problème : si on met -z $PAGE comme test ça ne fonctionne pas ! D'où cette astuce.
		        debile=0
		        else
		            if [ $PAGE = $p ]; then		         
                        DELTAH=`echo "$LISTEDELTA" | cut -d":" -f $l | cut -d"," -f2`
                        DELTAV=`echo "$LISTEDELTA" | cut -d":" -f $l | cut -d"," -f3`
	                fi
	            fi
	        done
	        
			DELTA="$DELTAH$dim $DELTAV$dim" 
	       
		#Tout est prêt.
			
		NOMPAGE="/tmp/pdflivre/$p.pdf"
		message " Export de la page $p sur $NPAGE\n Décalage vertical : $DELTAH pt\n Vers l'éxterieur  : $DELTAV pt" # Message
		pdfjam $IN $p --offset "$DELTA" --outfile $NOMPAGE
	done



rassemblement
cp $output $OUT -v

nettoyage

exit 0      # Et on ne fait pas d'imposition. C'est vraiment deux choses trop différentes:
            #+  Dans mon idée, on modifie son pdf, on le fait propre, ensuite seulement on l'impose.

fi









##########################################################

#    4.             IMPOSITION    

##########################################################





# 4 cas
# a. 4 pages par feuilles : on utilise pdfjam mais on traite avant le décalage
# b. 8 pages par feuilles : une fois avec 8 pages par cahier, une autre avec 16.
# c. 16 pages par feuilles





if [ "$NPFEUILLE" = 4 ]; then
##########################################################

#	  4.a      	4 pages par FEUILLES -> pdfbook
	
##########################################################

message 'IMPOSITION 4 PAGES par FEUILLE'



##### La fonction d'assemblage qui servira dans les deux cas du 4 pages

fonction_pdfbook ()
{
message ' Export du document final.'
if [ "$LIVRET" -eq 1 ]; then
		pdfbook $1 --landscape -o $OUT
	else
		pdfbook $1 --signature $NPCAHIER --landscape -o $OUT
	fi
}
#______________________________________________________________________




#####  Exécution de notre dessein avec une condition afin de traiter les décalages


if [ "$DELTAG" -eq 0 ] && [ "$DELTAV" -eq 0 ] && [ "$OFFSETG" -eq 0 ]; then   # aucun décalage :
    message 'Export du document final.'             # Eh oui! pdfjam fait ça très bien tout seul.
	
	fonction_pdfbook $IN

else                                                # Eh non! Là, y a un peu de travail.
        dispersion                   # "Dispersion" afin de traiter les décalages.
        rassemblement                # "Rassemblement"
      
    fonction_pdfbook $output

fi





elif [ "$NPFEUILLE" = 8 ]; then
##########################################################

#      4.b            	8 pages par FEUILLES

##########################################################

#					2 cas : 8 ou 16 pages par cahier



if [ "$NPCAHIER" = 8 ]; then
#=========================================================
#					8 pages par CAHIER
#=========================================================
message 'IMPOSITION 8 PAGES par FEUILLE \n et 8 p par CAHIER'

### DISPERSION des pages (avec les décalages)
dispersion



### Création de la liste de pages à TOURNER
	liste=''
	p=1
while [ $p -le "$NPAGE" ]
	do
		let " a = $p +1 " ; let " b = $p +6 " ;	let " c = $p +7 " 
		liste="$liste $p $a $b $c"
		let " p = $p +8"
	done
###	On TOURNE ces pages
retournement
###	On les rassemble en complétant par des pages blanches
rassemblement_complet



###	Reste à donner le BON ORDRE
	liste=''
	p=1
while [ $p -le "$NPTOTAL" ]
	do
		let " a = $p " 
		let " b = $p +7 "
		let " c = $p +3 "
		let " d = $p +4 "
		let " e = $p +6 "
		let " f = $p +1 "
		let " g = $p +5 "
		let " h = $p +2 "	
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h"
		let " p = $p +8"
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done


### EXPORTATION
message ' Export du document final.'
pdfjam --nup 2x2 $output $liste --outfile $OUT






elif [ "$NPCAHIER" = 16 ]; then
#=========================================================
#						16 pages par CAHIER 
#
#(Mais toujours en 8 pages par feuilles. 
#=========================================================
#Exemple : impression de 16 a5 sur 2 a3, on plie chaque feuille en 4 et on les emboîte ensemble) 
message 'IMPOSITION 8 PAGES par FEUILLE \n et 16 p par CAHIER'


### DISPERSION des pages (avec les décalages)
dispersion


###	Création de la liste des pages à TOURNER
	liste=''
	p=1
while [ $p -le "$NPAGE" ]
	do
		let " a = $p " ; let " b = $p +1 " ; let " c = $p +4 " ;	let " d = $p +5 " ; let " e = $p +10 " ; let " f = $p +11 " ; let " g = $p +14 " ; let " h = $p +15 "
		liste="$liste $a $b $c $d $e $f $g $h"
		let " p = $p +8"
	done

### On tourne ces pages
retournement
### On RASSEMBLE les pages
rassemblement_complet




###	IMPOSITION des pages (On fabrique la liste des pages dans le bon ordre)
	liste=''
	p=1
while [ $p -le "$NPTOTAL" ]
	do
		let " a = $p " 
		let " b = $p +15 "
		let " c = $p +3 "
		let " d = $p +12 "
		let " e = $p +14 "
		let " f = $p +1 "
		let " g = $p +13 "
		let " h = $p +2 "
		let " i = $p +4  " 
		let " j = $p +11 "
		let " k = $p +7 "
		let " l = $p +8 "
		let " m = $p +10 "
		let " n = $p +5 "
		let " o = $p +9 "
		let " q = $p +6 "		
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m,$n,$o,$q"
		let " p = $p +16 "
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

### EXPORTATION
message ' Export du document final.'
pdfjam --nup 2x2 $output $liste --outfile $OUT


# FIN de 8 pages par feuilles

else                        # Sinon : au secours
	aide
fi







elif [ "$NPFEUILLE" = 16 ]; then
####################################################################
#
#	4.c				16 pages par FEUILLE
#
####################################################################
message 'IMPOSITION 16 PAGES par FEUILLE'


NPCAHIER=16             # Y a pas à discuter (en tout cas pour l'instant)
let " NPTOTAL = ((( "$NPAGE" -1)/ "$NPCAHIER")+1)*"$NPCAHIER" "


### DISPERSION des pages
dispersion





### Création de la liste de pages à tourner
	liste=''
	p=1
while [ $p -le "$NPAGE" ]
	do
		let " a = $p +4 " ; let " b = $p +5 " ;	let " c = $p +6 " ; let " d = $p +7 " ; let " e = $p +8 " ; let " f = $p +9 " ; let " g = $p +10 " ; let " h = $p +10 "
		liste="$liste $a $b $c $d $e $f $g $h"
		let " p = $p +8 "
	done
### On tourne ces pages
retournement
### On les rassemble en complétant par des pages blanches
rassemblement_complet



### Reste à donner le bon ordre
	liste=''
	p=1
while [ $p -le "$NPTOTAL" ]
	do
		let " a = $p +4 " 
		let " b = $p +11 "
		let " c = $p +8 "
		let " d = $p +7 "
		let " e = $p +3 "
		let " f = $p +12 "
		let " g = $p +15 "
		let " h = $p "
		let " i = $p +6  " 
		let " j = $p +9 "
		let " k = $p +10 "
		let " l = $p +5 "
		let " m = $p +1 "
		let " n = $p +14 "
		let " o = $p +13 "
		let " q = $p +2 "		
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m,$n,$o,$q"
		let " p = $p +16"
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

### EXPORTATION
message ' Export du document final' 
pdfjam --landscape --nup 4x2 $output $liste --outfile $OUT




####################################################################
#
#					C'EST LA FIN .... MAIS



else			# Si c'est pas rentré dans les cases c'est que c'est pas bon....
	aide
fi

# Et puis on résume l'histoire

message "Ce message peut s'afficher malgré des erreurs!
Le fichier de sortie est : $OUT
pages par feuille        : $NPFEUILLE 
pages par cahier         : $NPCAHIER 
Décalage général des pages en pt
vers l'exterieur         : $DELTAG pt
vers le haut             : $DELTAV pt
Gouttière                : $OFFSETG pt"


nettoyage        #   Un peu d'écologie

Si vous utilisez ce script, merci de faire part de votre expérience, pour signaler une erreur ou confirmer qu'il n'y en a pas.

Ci-dessous quelques explications à propos de l'utilisation de pdfjam.

----------------------------Début de la "discussion"
Bonjour,
Nous étions quelques-uns à nous être penchés (en français) sur pdfjam. La doc est en effet assez abondante mais en anglais et il s'agit souvent de termes techniques. Et pdfjam en plus d'être puissant est de très bonne qualité (utilise TeX) et multiplateforme.
Ayant découvert une nouvelle utilisation de ce script, j'ouvre une nouvelle discussion mais je cite d'abord les résultats de la précédente discussion afin de rassembler les informations. Si j'avais le temps je ferais une page de wiki...

1.Utilisation générale
Installation par apt-get install pdfjam
D'une manière générale pdfjam concatène (rassemble) les pages de plusieurs documents en un seul. Cf pdfjam --help.
Exemple :

pdfjam doc1.pdf '1,5,10' doc2.pdf '{},5-15,20-'

crée un seul document dans le home avec un nom reprenant la commande qui contient dans l'ordre : les pages 1 5 et 10 de doc1 , une page blanche et les page 5 à 15 et 20 à la fin du document 2. Les documents peuvent être des fichiers images, les pages peuvent être tournées, agrandies...
Quelques options:
La taille du papier : --a3paper
Le format paysage : --landscape
--batch : un fichier de sortie par fichier d'entrée.
Le fichier de destination : par défaut il est appelé pdfjam-... .pdf et est envoyé dans le home.
Avec --outfile on peut :
OU préciser un dossier ET alors on peut préciser un suffixe avec --suffix (le suffixe s'intercale alors entre pdfjam-...- et .pdf)
OU préciser directement dossier/nom_de_fichier.pdf

2. L'imposition (vulgairement appelée : "faire un livret")
Comme dit plus bas pdfbook est une commande reprenant pdfjam avec certaines options. Lien pour une explication de l'imposition en imprimerie.

En réalité pdfbook sait imposer!
Pour des infos il faut visiter fichier texte (en anglais) dans le man des sources de pdfjam. facile, hein! Pourtant c'est un outil très recherché. Pdfjam

Deux exemples:
pdfbook input.pdf -o out.pdf Impose le pdf en cahier de 4 pages.
pdfbook --signature 12 input.pdf -o out.pdf Impose le pdf en cahier de 12 pages (3 pliants de 4 pages qui s'emboîtent)
Pour faire un livret il suffit d'entrer comme valeur à --signature le nombre de pages du document arrondi au multiple de 4 supérieur.

Autres options:
--short-edge : retournements sur bord court.
--no-landscape : pour portrait.

Limitation : seulement 2 pages par recto. ne peut imposer 4 A6 sur le recto d'un A4.

--edit:
pdfbook consiste uniquement à exécuter pdfjam avec l'option '--booklet true' ! Mais celle-ci n'a pas l'air d'accepter --nup et donc l'imposition de plus de 2 pages par face.

Pour conclure la commande complète sous pdfjam pour imposer en cahier de N pages :
 pdfjam --signature N --booklet true --landscape input.pdf -o output.pdf

sachant que latex fonctionne sous tous les OS c'est un outil interressant.
Resterait à fouiller pour l'imposition en plus de 2 pages par face...

J'ai l'impression que pdfjam --signature --booklet true --nup pourrait faire l'imposition en cahier de 16 pages sur une feuilles mais je n'y arrive pas.

Un bonus :
Dans Thunar il peut être utile pour certains d'ajouter pdfjam dans les actions personnalisées.
Exemple pour transformer un pdf en livret:

 pdfbook %f --suffix livret --outfile %d

3. L'"Offset
Il s'agit de déplacer les pages latéralement (On parle aussi de gouttière). Ce processus est spécialement utilisé pour compenser le fait que les feuillets extérieurs sont plus larges que les feuillets intérieurs. Il faut donc augmenter la marge intérieurs des premières et dernières pages afin qu'elles conservent les bonnes marges extérieures.
Je n'y suis pas encore mais ai fait le tout premier pas. Le script qui suit permet de décaler une page donnée d'un pdf.
Exemple :

~/pgm/offset ~/test.pdf '3' '5cm 0cm'

décale la page 3 de test.pdf de 5cm vers la droite et de 0cm vers le haut (on peut utiliser des valeurs négatives). Notez bien l'usage des quotes ( ' ).
Le script, pas bien compliqué :

#/bin/bash

pdf=$1
page=$2
offset=$3

let "pageav = $page - 1"
let "pageap = $page + 1"

pageavant=`echo "1-$pageav"`
pageapres=`echo "$pageap-"`
# Offset de la page qui nous intéresse.
pdfjam $pdf $page --offset "$offset" --outfile ~/tmp-xyz.pdf
# Assemblage avec les autres.
pdfjam $pdf $pageavant ~/tmp-xyz.pdf '1' $pdf $pageapres --outfile offset.pdf

echo -e "*************\nLa page $2 du document $1 a été déplacée de $3.\n*************"

rm ~/tmp-xyz.pdf

Il manque deux choses pour réaliser l'offset : que le script puissent prendre un nombre indéfini de pages avec des décalages variables, puis avec un décalage automatique.

serged

Je viens de découvrir ton pdfbook. Bravo ! J'ai réalisé (pour usage perso) un script semblable mais moins évolué, qui, néanmoins fait des dees booklet A6, plutôt que A5 (8 pages sur une page recto-verso au lieu de 4).

J'ai un peu zappé l'histoire des offsets. Néanmoins j'ai un problème :
Comment mettre les pages tête-bêche ? Par exemple pour un document de 8 pages, j'obtiens les pages 8-1 et 4-5 sur la même page dans le même sens. J'aimerais avoir 8-1 droit et 4-5 à l'envers (ou le contraire...)

À tout hasard, le script :

#!/bin/bash
# pdfa6
# Pour créer un livret à parti d'un document PDF A6

if [[ $# < 1 ]]
then
 echo "Usage :"
 echo $0 "nom fichier"
 exit
fi
IN=$1
OUT=`dirname "$IN"`/`basename "$IN" .pdf`-livre.pdf
echo Traitement de $1
pdfinfo "$IN"
NPAGE=`pdfinfo "$IN" |grep "Pages:"|cut -c 17-`
case $NPAGE in
# 4 pages : 4,1,{},{},2,3,{},{}
# 8 pages : 8,1,4,5,2,7,6,3
# 12 pages : 12,1,10,3,2,11,4,9,8,5,{},{},6,7,{},{}
# 16 pages : 16,1,8,9,2,15,10,7,14,3,12,5,4,13,6,11
 1) NP=4 ; liste="{},1,{},{},{},{},{},{}" ;;
 2) NP=4 ; liste="{},1,{},{},2,{},{},{}"  ;;
 3) NP=4 ; liste="{},1,{},{},2,3,{},{}"  ;;
 4) NP=4 ; liste="4,1,{},{},2,3,{},{}"  ;;
 5) NP=8 ; liste="{},1,4,5,2,{},{},3" ;;
 6) NP=8 ; liste="{},1,4,5,2,{},6,3" ;;
 7) NP=8 ; liste="{},1,4,5,2,7,6,3" ;;
 8) NP=8 ; liste="8,1,4,5,2,7,6,3" ;;
 9) NP=12; liste="{},1,{},3,2,{},4,{},8,5,{},{},6,7,{},{}" ;;
 10) NP=12; liste="{},1,{},3,2,{},4,9,8,5,{},{},6,7,{},{}" ;;
 11) NP=12; liste="{},1,10,3,2,11,4,9,8,5,{},{},6,7,{},{}" ;;
 12) NP=12; liste="12,1,10,3,2,11,4,9,8,5,{},{},6,7,{},{}" ;;
 13) NP=16; liste="{},1,8,9,2,{},10,7,{},3,12,5,4,13,6,11" ;;
 14) NP=16; liste="{},1,8,9,2,{},10,7,14,3,12,5,4,13,6,11" ;;
 15) NP=16; liste="{},1,8,9,2,15,10,7,14,3,12,5,4,13,6,11" ;;
 16) NP=16; liste="16,1,8,9,2,15,10,7,14,3,12,5,4,13,6,11" ;;
 *) echo "Document trop long ($NPAGE pages)" ; exit ;;
esac
echo $IN a $NPAGE pages, soit $NP pages, La liste est $liste
pdfjam --no-tidy --nup '2x2' --frame 'true' --no-landscape "$IN" $liste -o "$OUT"

Ouessant

Je m'empresse de corriger cette trop flatteuse attribution : pdfbook n'est pas de moi.
Pdfbook fait partie de pdfjam et n'est qu'un raccourci pour dire : pdfjam --booklet true --landscape.

Par contre votre question et votre script m'ont donné des idées et même des tas d'idées et j'ai pondu le script suivant qui traite plusieurs cas :

4 pages par feuilles (2 de chaque côté) : on utilise tout simplement pdfbook
8 pages par feuilles (4 de chaque côté, têtes au centre
- soit en 8 feuilles par cahier (les 8 premières pages constituent un cahier, au quel on ajoute le cahier suivant...
- soit en 16 pages par cahier (les 16 premières pages forment un cahier comportant de feuilles chacune pliées en 4 puis l'une emboîtée dans l'autre.
16 pages par feuilles (8 pages par côté. On plie la feuille en 16 pour former un cahier auquel on ajoute le suivant.

Je n'ai pas testé l'impression du résultat, je ne sais donc pas encore si des erreurs d'imposition ne se sont pas glissées dans le script.

Utilisation

pdflivre document.pdf nombre1 nombre2

où nombre 1 est le nombre de pages par feuilles (4, 8 ou 16)
et nombre 2 est le nombre de pages par cahier
dans le cas de 4 pages par feuilles il s'agit d'un multiple de 4. S'il n'est pas précisé, cela crée un livret.
dans le cas de 8 pages par feuilles : 8 ou 16
pas utilisé dans le cas unique de 16 pages par feuilles.

Idées
On pourrait ajouter une combinaison en 32 pages par cahier en 8 ou 16 pages par feuilles mais le résultat relié est souvent moche et puis l'alphabet ne compte que 24 lettres... Pour dire qu'il faut rentrer la place de chacune des 32 pages (Je ne suis pas un crac des algorithmes et n'ai pas trouvé de formule géniale pour établir l'ordre des pages. J'ai donc pris des feuilles de papier, les ai pliées et regardé ce que ça donnait.)
La prochaine fois que je suis pris d'une envie soudaine de scripter j'ajouterais plutôt la gouttière. Tous les outils sont là, y a plus qu'à l'introduire avant de tourner les pages. (Avec ça on règle la plupart des cas d'imposition, quitte à travailler son pdf avant pour les marques de coupe...)
Il serait bien aussi de trouver un moyen d'optimiser le programme car l'appel de pdfjam pour chaque page est assez long. Je pense à l'utilisation de pdfjam --batch $labonneliste . On pourrait aussi l'utiliser pour tourner les pages, mais ici sans un énorme gain .
Une toute petite option en plus serait le choix du fichier de sortie. On pourrait ajouter ça

if [ -z $4 ]; then
		OUT=`echo ~/pdflivre.pdf`
	else
		OUT=$4
	fi

au début mais dans ce cas il faudrait toujours $3 ce qui pose problème à pdfbook. Comment fait-on pour utiliser les options du genre --output ? À moins d'utiliser un if $3 = -o then OUT = $5 ; NBCAHIER=''... C'est pas beaucoup mieux. N'y a-t-il pas un moyen plus carré ?

Le code
Le script est commenté mais, étant autodidacte, j'ai probablement commis des hérésies que vous me pardonnerez. et j'explique donc brièvement la logique.
D'abord on extrait chacune des pages dans le dossier /tmp/pdflivre dans un document indépendant appelé numerodepage.pdf.
Ensuite on crée la liste des pages (donc une liste de documents) à tourner et on exécute un pdf180 $cetteliste.
Il suffit ensuite d'établir l'ordre des pages sous forme d'une autre liste et à éxecuter un pdfjam --nup ZxY $cetteautreliste.
Chaque liste est créée par une boucle créant les n° de pages à partir du n° de la première page du cahier (variable $p).

Le script (il semble très long mais c'est trois fois la même chose avec seulement les formules de liste qui changent).

#/bin/bash

mkdir -p /tmp/pdflivre

NPAGE=`pdfinfo "$1" |grep "Pages:"|cut -c 17-`
NPFEUILLE=$2 	#Le nombre de page par feuille peut-être 4 (pdfbook), 8 ou 16
NPCAHIER=$3 	#pour 4 page par feuille c'est "--signature" de pdfbook.
let " NPTOTAL = ((( "$NPAGE" -1)/ "$NPCAHIER")+1)*"$NPCAHIER" "
OUT=`echo ~/pdflivre.pdf`

if [ $NPFEUILLE = 4 ]; then
##########################################################
#4 pages par FEUILLES -> pdfbook
	if [ -z $3 ]; then
		pdfbook $1 --landscape -o $OUT
	else
		pdfbook $1 --signature $3 --landscape -o $OUT
	fi
##########################################################

elif [ $NPFEUILLE = 8 ]; then
##########################################################
#8 pages par FEUILLES
#		2 cas : 8 ou 16 pages par cahier
if [ $NPCAHIER = 8 ]; then
#---------------------------------------------------------
#	8 pages par CAHIER
#On disperse les pages
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		NOMPAGE="/tmp/pdflivre/$p.pdf"
		pdfjam $1 $p --outfile $NOMPAGE
	done

#Création de la liste de pages à tourner
	liste=''
	p=1
while [ $p -lt "$NPAGE" ]
	do
		let " a = $p +1 " ; let " r = $p +6 " ;	let " s = $p +7 " 
		liste="$liste $p $q $r $s"
		let " p = $p +8"
	done

#On tourne ces pages
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
	echo "$NOMPAGE"	
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done

#On les rassemble en complétant par des pages blanches
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done

while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output

#Reste à donner le bon ordre
	liste=''
	p=1
while [ $p -lt "$NPTOTAL" ]
	do
		let " a = $p " 
		let " b = $p +7 "
		let " c = $p +3 "
		let " d = $p +4 "
		let " e = $p +6 "
		let " f = $p +1 "
		let " g = $p +5 "
		let " h = $p +2 "	
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h"
		let " p = $p +8"
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

#Exportation
pdfjam --nup 2x2 $output $liste --outfile $OUT

elif [ $NPCAHIER = 16 ]; then
#--------------------------------------------------------------------
#	16 pages par CAHIER (Mais toujours en 8 pages par feuilles. Exemple : impression de 16 a5 sur 2 a3, on plie chaque feuille en 4 et on les emboîte ensemble) 
#On disperse les pages
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		NOMPAGE="/tmp/pdflivre/$p.pdf"
		pdfjam $1 $p --outfile $NOMPAGE
	done

#Création de la liste de pages à tourner
	liste=''
	p=1
while [ $p -lt "$NPAGE" ]
	do
		let " a = $p " ; let " b = $p +1 " ; let " c = $p +4 " ;	let " d = $p +5 " ; let " e = $p +10 " ; let " f = $p +11 " ; let " g = $p +14 " ; let " h = $p +15 "
		liste="$liste $a $b $c $d $e $f $g $h"
		let " p = $p +8"
	done

#On tourne ces pages
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
	echo "$NOMPAGE"	
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done

#On les rassemble en complétant par des pages blanches
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done

while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output

#Reste à donner le bon ordre
	liste=''
	p=1
while [ $p -lt "$NPTOTAL" ]
	do
		let " a = $p " 
		let " b = $p +15 "
		let " c = $p +3 "
		let " d = $p +12 "
		let " e = $p +14 "
		let " f = $p +1 "
		let " g = $p +13 "
		let " h = $p +2 "
		let " i = $p +4  " 
		let " j = $p +11 "
		let " k = $p +7 "
		let " l = $p +8 "
		let " m = $p +10 "
		let " n = $p +5 "
		let " o = $p +9 "
		let " q = $p +6 "		
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m,$n,$o,$q"
		let " p = $p +16 "
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

#Exportation
pdfjam --nup 2x2 $output $liste --outfile $OUT


#FIN de 8 pages par feuilles
else 
	echo "Dans le cas de 8 pages par feuilles, le nombre de pages par cahier ne peut être que de 8 ou de 16"
fi


elif [ $NPFEUILLE = 16 ]; then
####################################################################
#	16 pages par FEUILLE
NPCAHIER=16
let " NPTOTAL = ((( "$NPAGE" -1)/ "$NPCAHIER")+1)*"$NPCAHIER" "
#On disperse les pages
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		NOMPAGE="/tmp/pdflivre/$p.pdf"
		pdfjam $1 $p --outfile $NOMPAGE
	done

#Création de la liste de pages à tourner
	liste=''
	p=1
while [ $p -lt "$NPAGE" ]
	do
		let " a = $p +4 " ; let " b = $p +5 " ;	let " c = $p +6 " ; let " d = $p +7 " ; let " e = $p +8 " ; let " f = $p +9 " ; let " g = $p +10 " ; let " h = $p +10 "
		liste="$liste $a $b $c $d $e $f $g $h"
		let " p = $p +8 "
	done

#On tourne ces pages
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
	echo "$NOMPAGE"	
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done

#On les rassemble en complétant par des pages blanches
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done
echo "SUPER"
while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output

#Reste à donner le bon ordre
	liste=''
	p=1
while [ $p -lt "$NPTOTAL" ]
	do
		let " a = $p +4 " 
		let " b = $p +11 "
		let " c = $p +8 "
		let " d = $p +7 "
		let " e = $p +3 "
		let " f = $p +12 "
		let " g = $p +15 "
		let " h = $p "
		let " i = $p +6  " 
		let " j = $p +9 "
		let " k = $p +10 "
		let " l = $p +5 "
		let " m = $p +1 "
		let " n = $p +14 "
		let " o = $p +13 "
		let " q = $p +2 "		
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m,$n,$o,$q"
		let " p = $p +16"
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

#Exportation
pdfjam --landscape --nup 4x2 $output $liste --outfile $OUT


#fin de la condition générale
else 
	echo -e "**********************************\nUsage : pdflivre document.pdf nombre1 nombre2\n    où nombre1 est le nombre de pages par feuilles (4,8 ou 16) \n    et nombre2 le nombre de pages par cahier \n         libre pour 4 pages par feuilles, non précisé : imposition en livret unique.\n         de 8 ou de 16 pour 8 pages par feuilles.\n         non disponible pour 16."
fi

rm -r /tmp/pdflivre

Ouessant

Nouvelle mouture : avec getopts pour les options.

Pour ceux qui n'ont jamais exécuté (promis c'est pas violent!) de script :
- créer un fichier texte vierge et le nommer uniquement : pdflivre
- copier tout le texte du script ci-dessous dans ce fichier, le fermer en l'enregistrant.
- clic droit sur le fichier > Propriétés > Permissions > Cocher "Autoriser ce fichier à s'exécuter comme un programme".
- ouvrir un terminal, attraper votre fichier et l'y faire glisser. Taper entrée, le message d'aide s'affiche.

Le script (là il devient un peu long, mais il est toujours vrai qu'après le getopts et les fonction, le reste se répète trois fois).
pdflivre -h pour la description des options.

#/bin/bash

################    AIDE
aide ()
{
	echo -e "
USAGE : pdflivre [OPTIONS]\n
Manipulation de pdf utilisant pdfjam (TeX).
Imposition en livret ou en cahier, déplacement des pages, gouttière.\n
Seule la première option est obligatoire.
   -i FICHIER    FICHIER est un document pdf (format portrait).
   -o FICHIER    FICHIER est le document de sortie.
                       [Défaut : ~/pdflivre.pdf].
   -f NPFEUILLE  NPFEUILLE est le nombre de pages par feuilles.
                     * 4 : 2 pages par face (utilise pdfbook).
                     * 8 
                     * 16                       [Defaut: 4]
   -c NPCAHIER   NPCAHIER est le nombre de pages par cahier.
                     * libre pour 4 pages par feuilles,
                            1 pour un seul livret [Defaut].
                     * de 8 ou de 16 pour 8 pages par feuilles.
                     * non disponible pour 16.
   -d DELTAH    DELTAH est un nombre. Il permet de décaler toutes
                     les pages vers le haut d'autant de pt.
   -v DELTAV    Décalage les pages vers l'extérieur d'autant de pt.
   -g GOUTTIÈRE Toujours un nombre en point. C'est le décalage
                     vers l'extérieur des pages extérieures
                     des cahiers. Les autres pages sont décalées
                     proportionnelement.
   -h           Cette aide.
"
exit 0
}
####################




mkdir -p /tmp/pdflivre

##########################################################

#	Les variables

##########################################################

while getopts "i:o:c:f:d:v:g:h" option ; do
 case $option in
   i) IN="$OPTARG";;
   o) OUT="$OPTARG";;
   c) NPCAHIER="$OPTARG";;
   f) NPFEUILLE="$OPTARG";;  
   d) DELTAG="$OPTARG";;              #	Décalage horizontal vers l'extérieur (pour toutes les pages) 
   v) DELTAV="$OPTARG";; 
   g) OFFSETG="$OPTARG";;              #	Offset (décalage vers l'extérieur des pages extérieures 
                                          #+	des cahiers, les intérieures sont décalées selon 
                                          #	une fonction linéaire)
   h) aide ;;
   ?) echo "Option -$OPTARG inconnue" ; aide ;;
 esac
done

if [ -z $IN ]; then
  aide
fi

if [ -z $OUT ]; then
   OUT=`echo ~/pdflivre.pdf`
fi

if [ -z $NPCAHIER ]; then           #	Nombre de page par cahier : pour 4 page par feuille 
    NPCAHIER=1                           #+	c'est "--signature" de pdfbook.
fi
         
if [ -z $NPFEUILLE ]; then          #	Le nombre de page par feuille : peut-être 4 (pdfbook), 8 ou 16
    NPFEUILLE=4
fi
            
if [ -z $DELTAG ]; then             #	Décalage horizontal vers l'extérieur (pour toutes les pages)
    DELTAG=0
fi 

if [ -z $DELTAV ]; then             #	Décalage vertical (pour toutes les pages)
    DELTAV=0
fi 

if [ -z $OFFSETG ]; then            #	Offset (décalage vers l'extérieur des pages extérieures 
    OFFSETG=0                          #+	des cahiers, les intérieures sont décalées selon 
fi                                      #	une fonction linéaire)
   
   
   
NPAGE=`pdfinfo "$IN" |grep "Pages:"|cut -c 17-`                  #   Nombre de page du pdf.						
let " NPTOTAL = ((( "$NPAGE" -1)/ "$NPCAHIER")+1)*"$NPCAHIER" " #   Nombre final de page du pdf : premier multiple du nombre de cahier.
 							


##########################################################

#	Les fonctions

##########################################################


####### 	Pour faire joli et donner des nouvelles
message ()
{
echo -e "\n********************************************\n$1 \n********************************************\n" 
}



####### 	Fonction de dispersion des pages en autant de documents


dispersion ()
{
	p=0
	pt='pt' 						#	Variable bidon pour éviter d'écrire "$VAR pt"
									#+	qui donne 10 pt et donc une erreur. 
									#+	Il faut "$VAR$pt" et 10pt (en l. 67).
	#	Calcul de l'offset :
#		Pour les pages le plus à l'extérieur il faut tout l'offset. Exemple dans le cas de 8
#		pages par cahier : les pages 1 et 8, puis 9 et 16...
#		Tandis que l'offset doit être à 0 pour les pages intérieures. Ex : 4 et 5.
#		Dans notre exemple on va donc tacher de donner 3/3 d'offset aux pages 1 et 8,
#		2/3 aux 2 et 7, 1/3 aux 3 et 6, 0/3 aux 4 et 5.
#		y est ce 3 , x prend les valeurs de 3 à 0 puis 0 à 3 grâce à z qui le fait s'incrémenter ou se décrémenter... 
	let " y = ($NPCAHIER /2)-1 "
	x="$y"
	z=-1

#######	La boucle de dispersion

while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		
		#	Calcul de l'offset (Histoire x,y et z...
		let " x = x + z "
				case $x in
					0|"$y") let " z = - $z " ;;
				esac		
		let " DELTAH = $DELTAG + (($x* $OFFSETG)/$y) " 		# 	Le delta horizontal vaut le delta
															#+ 	general plus l'offset
		
		#	Le décalage horizontal doit être négatif pour les pages impaires 
			#+	afin d'être toujours vers l'exterieur.
		let " n = 2* ($p /2) " 
				if [ $p -eq "$n" ]; then
					DELTA="-$DELTAH$pt $DELTAV$pt"
						
				else
					DELTA="$DELTAH$pt $DELTAV$pt" 
				fi
		
		#Tout est prêt.
			
		NOMPAGE="/tmp/pdflivre/$p.pdf"
		message "Export de la page $p sur $NPAGE\n décalée de $DELTAH$pt $DELTAV$pt" # Message
		pdfjam $IN $p --offset "$DELTA" --outfile $NOMPAGE
	done
}




if [ $NPFEUILLE = 4 ]; then
##########################################################

#				   	4 pages par FEUILLES -> pdfbook
	
##########################################################
message 'Export du document final.'             # Eh oui! pdfjam fait ça très bien tout seul.
	
	if [ $NPCAHIER -eq 1 ]; then
		pdfbook $IN --landscape -o $OUT
	else
		pdfbook $IN --signature $NPCAHIER --landscape -o $OUT
	fi




elif [ $NPFEUILLE = 8 ]; then
##########################################################

#                  	8 pages par FEUILLES

##########################################################

#					2 cas : 8 ou 16 pages par cahier

if [ $NPCAHIER = 8 ]; then
#---------------------------------------------------------
#					8 pages par CAHIER
#---------------------------------------------------------


#######	DISPERSION des pages
message 'DISPERSION'
dispersion



####################	Création de la liste de pages à TOURNER
	liste=''
	p=1
while [ $p -le "$NPAGE" ]
	do
		let " a = $p +1 " ; let " b = $p +6 " ;	let " c = $p +7 " 
		liste="$liste $p $a $b $c"
		let " p = $p +8"
	done

####################	On TOURNE ces pages
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
				let " POURCENT = (100 * $p) / $NPTOTAL "			# Un petit message
				message "Rotation des pages : $POURCENT %" 
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done

####################	On les rassemble en complétant par des pages blanches
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done

while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output

####################	Reste à donner le bon ordre
	liste=''
	p=1
while [ $p -le "$NPTOTAL" ]
	do
		let " a = $p " 
		let " b = $p +7 "
		let " c = $p +3 "
		let " d = $p +4 "
		let " e = $p +6 "
		let " f = $p +1 "
		let " g = $p +5 "
		let " h = $p +2 "	
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h"
		let " p = $p +8"
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

####################	Exportation
message 'Export du document final.'
pdfjam --nup 2x2 $output $liste --outfile $OUT




elif [ $NPCAHIER = 16 ]; then
#--------------------------------------------------------------------
#						16 pages par CAHIER 
#--------------------------------------------------------------------
#(Mais toujours en 8 pages par feuilles. Exemple : impression de 16 a5 sur 2 a3, on plie chaque feuille en 4 et on les emboîte ensemble) 



#######	DISPERSION des pages
message 'DISPERSION'
dispersion


#########	On TOURNE les pages qu'il faut


#########	Création de la liste des pages à tourner
	liste=''
	p=1
while [ $p -le "$NPAGE" ]
	do
		let " a = $p " ; let " b = $p +1 " ; let " c = $p +4 " ;	let " d = $p +5 " ; let " e = $p +10 " ; let " f = $p +11 " ; let " g = $p +14 " ; let " h = $p +15 "
		liste="$liste $a $b $c $d $e $f $g $h"
		let " p = $p +8"
	done

#########	On tourne ces pages
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
				let " POURCENT = (100 * $p) / $NPTOTAL "			# Un petit message
				message "Rotation des pages : $POURCENT %" 	
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done


#########	On RASSEMBLE les pages (la liste est la liste des pages dans l'ordre).

liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done

while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output


#########	IMPOSITION des pages (On fabrique la liste des pages dans le bon ordre)
	liste=''
	p=1
while [ $p -le "$NPTOTAL" ]
	do
		let " a = $p " 
		let " b = $p +15 "
		let " c = $p +3 "
		let " d = $p +12 "
		let " e = $p +14 "
		let " f = $p +1 "
		let " g = $p +13 "
		let " h = $p +2 "
		let " i = $p +4  " 
		let " j = $p +11 "
		let " k = $p +7 "
		let " l = $p +8 "
		let " m = $p +10 "
		let " n = $p +5 "
		let " o = $p +9 "
		let " q = $p +6 "		
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m,$n,$o,$q"
		let " p = $p +16 "
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

#########	Exportation
message 'Export du document final.'
pdfjam --nup 2x2 $output $liste --outfile $OUT


#########	FIN de 8 pages par feuilles

else 
	echo "Dans le cas de 8 pages par feuilles, le nombre de pages par cahier ne peut être que de 8 ou de 16"
fi


elif [ $NPFEUILLE = 16 ]; then
####################################################################
#
#					16 pages par FEUILLE
#
####################################################################



NPCAHIER=16
let " NPTOTAL = ((( "$NPAGE" -1)/ "$NPCAHIER")+1)*"$NPCAHIER" "


#######	DISPERSION des pages
message 'DISPERSION'
dispersion



#########	Création de la liste de pages à tourner
	liste=''
	p=1
while [ $p -le "$NPAGE" ]
	do
		let " a = $p +4 " ; let " b = $p +5 " ;	let " c = $p +6 " ; let " d = $p +7 " ; let " e = $p +8 " ; let " f = $p +9 " ; let " g = $p +10 " ; let " h = $p +10 "
		liste="$liste $a $b $c $d $e $f $g $h"
		let " p = $p +8 "
	done



#########	On tourne ces pages
for p in $liste
	do
	NOMPAGE="/tmp/pdflivre/$p.pdf"
	echo "$NOMPAGE"	
	pdf180 $NOMPAGE --outfile $NOMPAGE
	done



#########	On les rassemble en complétant par des pages blanches
liste=''
p=0
while [ $p != "$NPAGE" ]
	do
		let " p = $p +1 "
		liste="$liste /tmp/pdflivre/$p.pdf 1"
	done

while [ $p != "$NPTOTAL" ]
	do	
		let " p = $p +1 "
		liste="$liste,{}"
	done

output=/tmp/pdflivre/temp.pdf
pdfjam $liste -o $output



#########	Reste à donner le bon ordre
	liste=''
	p=1
while [ $p -le "$NPTOTAL" ]
	do
		let " a = $p +4 " 
		let " b = $p +11 "
		let " c = $p +8 "
		let " d = $p +7 "
		let " e = $p +3 "
		let " f = $p +12 "
		let " g = $p +15 "
		let " h = $p "
		let " i = $p +6  " 
		let " j = $p +9 "
		let " k = $p +10 "
		let " l = $p +5 "
		let " m = $p +1 "
		let " n = $p +14 "
		let " o = $p +13 "
		let " q = $p +2 "		
				liste="$liste$a,$b,$c,$d,$e,$f,$g,$h,$i,$j,$k,$l,$m,$n,$o,$q"
		let " p = $p +16"
			if [ $p -lt "$NPTOTAL" ]; then 
				liste="$liste," 
			fi
	done

#########	Exportation
message 'Export du document final' 
pdfjam --landscape --nup 4x2 $output $liste --outfile $OUT


#fin de la condition générale
else			# Si c'est pas rentré dans les cases c'est que c'est pas bon....
	aide
fi

message "Le fichier de sortie est $OUT :\nIl compte $NPFEUILLE pages par feuille et $NPCAHIER par cahier.\nDécalage général des pages :\n    $DELTAG vers l'exterieur \n    $DELTAV pt vers le haut \nGouttière : de $OFFSETG vers l'exterieur pour les pages extérieures des cahiers."


rm -r /tmp/pdflivre

Ouessant

Des exemples :

pdflivre -i monfichier.pdf - o sortie.pdf -f 4

Transforme monfichier.pdf en sortie.pdf.
Ce sortie.pdf rassemble 2 pages par verso de sorte qu'une fois la liasse pliée en deux j'ai un livret.
On a donc 4 pages par feuilles (2 de chaque côté).

pdflivre -i monfichier.pdf - f 4 -c 16

Cette fois le fichier de sortie est le fichier par défaut : pdflivre.pdf .
On met toujous 4 pages par feuilles, mais
16 pages par cahier : je prendrai donc les 4 premières feuilles qui sortent de l'imprimante, les plierai en deux, puis les 4 suivantes... chaque groupe forme un cahier de 16 pages (4 x 4), les cahier cousus ensemble forment le livre.

pdflivre -i monfichier.pdf - f 8 -c 8

8 pages par feuilles : il faut plier chaque feuille en trois.
en cahier de 8 pages : chaque feuille pliée forme un cahier.

pdflivre -i monfichier.pdf - f 8 -c 16

là il faut 2 feuilles pliées en 3 et emboîtées l'une dans l'autre pour former un cahier.

Décalage général : OPTIONS -d -v

pdflivre -i monfichier.pdf - f 4 -v 5

Bon un livret mais je remonte toutes les pages de 5pt vers le haut. ( -v '-5' pour le bas )

pdflivre -i monfichier.pdf - f 4 -v 5 -d 10

Toujours un livret en sortie.
Les pages remontent toujours de 5 pt.
mais en plus sont décalées de 10pt vers l'extérieur (page impaires vers la droite et paires vers la gauche).

GOUTTIERE option -g , gestion des décalages dus à l'épaisseur du papier.

pdflivre -i monfichier.pdf - f 4 -g 10

Mon pdf fait 40 pages. En livret ça fait 10 feuilles. Celles-ci pliées en deux ça fait que les pages 1 et 40 ont une distance plus longue à parcourir et parfois ma marge intérieure y passe.
Sauf que -g 10, les pages extérieures sont décalées vers l'extérieur de 10pt. Et à mesure qu'on s'approche du centre du livret la gouttière s'annule.

DECALAGE page par page

pdflivre -i monfichier.pdf - m '10,5,0:15,-5,-5'

Lors de mon scan les pages 10 et 15 ont un peu bougées...
Cette commande décale la page 10 de 5pt vers la droite et la page 15 de 5pt vers la gauche et 5pt vers le bas. (ICI sans considération de la parité des pages).

leorebetez

Salut,

Ton script semble être exactement ce dont j'ai besoin.
Le problème c'est que j'ai vraiment de la peine à comprendre ce qu'il faut faire et comment... Je suis nouveau sous Ubuntu et je tente de me faire gentiment mes marques, mais là je suis bloqué à la toute première étape avec ce script...
Dans quel programme crées-tu le fichier texte? J'ai essayé avec Abiword, Libreoffice et Gedit, Je n'arrive pas à lui accorder la permission sous propriétés, cette option n'existe simplement pas sur mon système...

Merci

leorebetez

Alors j'ai pu me renseigner auprès d'un familier de la ligne de code qui m'a expliqué comment faire. Je vais donc expliquer ceci ici s'il y en a qui comme moi ne se sont pas encore trop copains avec le terminal et tout ça.

J'ai donc ouvert gedit où j'ai copié le script comme indiqué plus haut.
Puis fichier > enregistrer sous et changer l'extension du fichier en ".sh". Cela revient à nommer le fichier "pdflivre.sh"
Ensuite, il est possible, lorsqu'on fait un clic droit sur le fichier, de le rendre exécutable.
Si on glisse le fichier pdflivre.sh dans le terminal puis qu'on presse "enter", le menu d'aide s'affiche.
Pour créer son pdf imposé, il faut glisser le fichier pdflivre.sh dans le terminal, suivi d'un espace et du fichier pdf auquel on veut faire subir une imposition. Il suffit ensuite de suivre les instructions indiquées plus haut et de laisser la magie opérer.

Ce script semble fonctionner à merveille et c'est super! Merci!

Ouessant

Bonjour Leorebetez, et bienvenue sous linux.
En effet, depuis je ne sais quand, le menu ne propose de rendre exécutable que les fichiers en .sh. Merci de l'avoir indiqué pour les autres.
Heureux de vous avoir été utile, vérifiez bien quand même le résultat avant de lancer une impression offset en 3000 exemplaires… je ne fournis pas de garantie ! :/ Quand on sait le prix du module adobe, on se risque à bidouiller des trucs gratuits…

Ouessant

Je passais sur le forum justement pour une histoire de pdf : j'ajoute sur un pdf produit bêtement sur libreoffice (pas ma faute…) des numéros de pages un peu compliqués conçus sous scribus. Du coup j'avais importé dans des cadres images chaque page du pdf sur chaque page scribus. Jusque là rien d'extraordinaire. Sauf que le pdf de 10Mo à l'entrée en faisait 400 à la sortie !!! Inutilisable.

Alors il existe une formule magique pour superposer deux pdf (disponible dans la doc mais je la remets ici) :

pdftk document.pdf multibackground fond.pdf output sortie.pdf

J'ai donc utilisé pour fond la sortie de scribus dont j'avais enlevé le pdf d'entrée. Le résultat est à peine plus gros.

nickwe

Ce script est une pure merveille, tout grand merci Ouessant :-)

Je cherchais depuis plus de 2 heures et c'est par hasard en dernier recours que je suis tombé dessus, mes besoins étaient 8 pages par feuilles pour un document de 128 pages et le résultats est bluffant! Reste plus qu'à imprimer...

Nicolas.

Ouessant

Avec plaisir.

Yaume

Super script, ça a marché du premier coup pour faire un petit livre de 56 pages A6 imprimé sur du A4. Merci bien!

PS. À quand un nouveau script pour les pliages et les reliures ?

eric63

salut
bon j'ai ramé un peu pour le lancer ce script sur kde5.6.4 avec konsole
et j'ai réussi en faisant

/home/kubu/programme/pdflivre.sh -i /home/kubu/Documents/DPTroglodytedeJonas2015.pdf 
NPCAHIER = 12
LIVRET

=============================
IMPOSITION 4 PAGES par FEUILLE

=============================
Export du document final.

=============================
 Export du document final.
          ----
  pdfjam: This is pdfjam version 2.08.
  pdfjam: Reading any site-wide or user-specific defaults...
          (none found)
  pdfjam: Effective call for this run of pdfjam:
          /usr/bin/pdfjam --booklet 'true' --landscape --suffix book --signature '4' --landscape --outfile /home/kubu/pdflivre.pdf -- /home/kubu/Documents/DPTroglodytedeJonas2015.pdf - 
  pdfjam: Calling pdflatex...
  pdfjam: Finished.  Output was to '/home/kubu/pdflivre.pdf'.

=============================
Ce message peut s'afficher malgré des erreurs!
Le fichier de sortie est : /home/kubu/pdflivre.pdf
pages par feuille        : 4 
pages par cahier         : 12 
Décalage général des pages en pt
vers l'exterieur         : 0 pt
vers le haut             : 0 pt
Gouttière                : 0 pt

il y a un programme sur kde look qui lui ressemble sans l'égaler mais il a un avantage c'est qu'il est graphique et que tout passe par les options du menu menupdf
j'aime bien aussi le fait que la sortie du document final est une copie de l'original avec un ajout livret ou 4x4 suivant la pagination et se pose à coté du fichier original ce qui me semble une bonne idée.
est ce que vous pourriez envisager la même chose pour votre script ?

L'Africain

Bonjour à tous,
Je cherche une application qui pourrait faire de l'imposition comme votre petit script, je l'ai testé avec deux pages A5 (recto verso) qui contiennent chacune deux pages A6 (cf mon post ici. Je voudrais imprimer deux fois la page A5 numéro 1 sur le recto et la 2 deux fois aussi sur le verso. J'ai testé le script il fonctionne à part qu'à la sortie il me met les pages A5 dans en portrait au lieu de me les mettre en paysage sur la A4 portrait.
Y-a-t-il une option qui permettrait d'arranger ça?
Merci pour votre aide.

Edit : Concernant menupdf est-il possible de l'utiliser sans KDE?
Edit bis: Avec le script de serged ça fonctionne parfaitement !! Merci pour le script de ouessan si je dépasse les 16 pages A6 certaines pages sortent blanches. Merci pour vos contributions.

Ouessant

Bien que vous ayez trouvé la solution, je réponds pour les suivants.
La seule solution à partir de mon script aurait été de le modifier pour rentrer l'option no-landscape au bon endroit, ce qui n'est vraiment pas convivial. Autant revenir aux commandes de base à partir de pdfjam.
Ce script devient vraiment intéressant quand on veut faire une imposition par cahier et avoir une gouttière. J'y ai intégré le reste pour qu'il soit plus complet. Mais ça reste qu'un script en attendant que quelqu'un sorte un vrai programme gratuit, plus sûr et plus rapide, en remplacement des outils payants et très chers…
Merci pour vos retours de bugs, même si c'est presque une torture de devoir relire son code 6 mois après pour retrouver la faute.
Cependant, question banale mais qui m'éviterait de débugger, les pages blanches ne tombent-elles pas au bon endroit ? C'est-à-dire que nécessairement si on impose 23 pages en deux cahiers de 16 pages, on va se retrouver avec des tas de pages blanches…

L'Africain

Ok ça marche !
Donc pour 16 pages 16 sur 4 pages A4 j'emploie les options -f 8 -c 16.
Merci pour tout.

leorebetez

Salut,

Merci beaucoup pour ce script qui fonctionne à merveille. Grâce à lui, j'ai réalisé l'année passée un agenda en cahiers de 8 pages, c'est formidable et ça fonctionne aussi très bien pour des livrets plus simples.

J'ai une petite question toutefois: voyez-vous un moyen pour réaliser une imposition pour la reliure collée? Je m'explique: pour de prochaines réalisations, j'aimerais faire des livres au format A6. Le but serait de quand même imprimer 8 pages par feuilles, mais de ne pas avoir à plier des tonnes de cahiers. Il faudrait donc que sur ma première feuille A4, j'aie au recto 4 pages n°1, et au verso 4 pages n°2 etc.
Voyez-vous le principe? Cela ne me semble pas possible avec ce script-ci, mais la fonction doit être relativement proche. Est-ce que quelqu'un aurait une idée?

Merci!

serged

leorebetez a écritSalut,

Merci beaucoup pour ce script qui fonctionne à merveille. Grâce à lui, j'ai réalisé l'année passée un agenda en cahiers de 8 pages, c'est formidable et ça fonctionne aussi très bien pour des livrets plus simples.

J'ai une petite question toutefois: voyez-vous un moyen pour réaliser une imposition pour la reliure collée? Je m'explique: pour de prochaines réalisations, j'aimerais faire des livres au format A6. Le but serait de quand même imprimer 8 pages par feuilles, mais de ne pas avoir à plier des tonnes de cahiers. Il faudrait donc que sur ma première feuille A4, j'aie au recto 4 pages n°1, et au verso 4 pages n°2 etc.
Voyez-vous le principe? Cela ne me semble pas possible avec ce script-ci, mais la fonction doit être relativement proche. Est-ce que quelqu'un aurait une idée?

Merci!

Le script que j'ai écrit (les explications sur mon site) fait ça. Malheureusement il y a un problème avec les pages qui ne sont pas tête-bêche. Là, je sèche...