Siehe auch Zeichensätze konvertieren

Mit CSV-Dateien kann man das Problem haben, dass das Trennzeichen zwischen den Datensätzen auch in den Daten enthalten sein darf. Bei TSV-Dateien ist das verboten. Excel kann beide Formate aber zum Beispiel "LibreOffice" unterstützt leider nur das CSV-Format…

Dateiformate konvertieren mit LibreOffice

Convert XLSX to CSV correctly using python

> apt install python-xlrd
> /usr/local/bin/xlsx2csv.sh sheet.xlsx
> ls -lha *.csv

/usr/local/bin/xlsx2csv.sh

#!/bin/bash
 
# XLSX => CSV
 
if [ -r "${1}" ] ; then
        XLSX_DATEI="${1}"
        #XLSX_VERZ="$(dirname "${XLSX_DATEI}")"
        XLSX_NAME="$(basename "${XLSX_DATEI}")"
else
        echo "Die XLSX-Datei '${1}' kann nicht gelesen werden."
        exit 1
fi
 
ALLE_SHEET_NAMEN="$(runxlrd -e'utf-8' -f0 ov ${XLSX_DATEI} | grep -E '^sheet [0-9]' | sed 's/://')"
ALLE_SHEET_NR="$(echo "${ALLE_SHEET_NAMEN}" | awk '{print $2}')"
 
for SHEET_NR in ${ALLE_SHEET_NR}
do
        SHEET_NM="$(echo "${ALLE_SHEET_NAMEN}" | grep -E "^sheet ${SHEET_NR} " | awk -F"'" '{print $2}')"
        echo
        echo "...sheet ${SHEET_NR} '${SHEET_NM}' ist in Bearbeitung..."
 
        runxlrd -e'utf-8' -f0 -s${SHEET_NR} show ${XLSX_DATEI} | awk '/^cell /{gsub(":"," ");gsub(" u"," ");print $2,$5}' | sed -e 's/^[A-Z]*/& /' -e "s/'//g" | while read SPALTE ZEILE INHALT
        do      
                if [ "${_Z}" = 0 ] ; then
                        _Z="${ZEILE}"
                elif [ "${_Z}" != "${ZEILE}" ] ; then
                        _Z="${ZEILE}"
                        echo
                fi
                echo -n "${INHALT};"
        done > "${SHEET_NR}.${SHEET_NM}.${XLSX_NAME}".csv
        echo "fertig: ${SHEET_NR}.${SHEET_NM}.${XLSX_NAME}.csv"
done 

Leider wird csv nicht als Eingabeformat/Quellformat akzeptiert! Deshalb hat jemand ein Python-Script geschrieben, mit dem man CSV-Dateien in XLS-Dateien umwandeln kann. Um dieses Script nutzen zu können muss man erst das Modul "pyExcelerator" installiern. Dieses Modul kann Excel-97/2000/XP/2003-Dateien erzeugen, man kann es von hier beziehen (es steht unter BSD-Lizenz):

• http://sourceforge.net/projects/pyexcelerator/

# unzip -L ~/Downloads/pyexcelerator-0.6.4.1.zip
# cd pyexcelerator-0.6.4.1/
# python setup.py install

# ./csv2xls.py -h
# ./csv2xls.py -o test.xls test.csv
# ./csv2xls.py -s';' -t -o test.xls test.csv

Die meisten machen sowas mit Excel oder OpenOffice per Hand, einige machen das auch mit Perl.

Siehe auch hier: PDF-Dateien in TXT-Dateien umwandeln

# aptitude install ps2eps ghostscript

# pdf2ps Originaldatei.pdf datei.ps
# ps2ascii datei.ps > datei.txt

#!/usr/bin/env bash

if [ -z "${1}" ] ; then
        echo "${0} Datei1.pdf Datei2.pdf Datei3.pdf"
        exit 1
fi

if [ -z "$(which pdf2ps)" ] ; then
        echo "pdf2ps (Ghostscript) ist nicht installiert"
        exit 1
fi

if [ -z "$(which ps2ascii)" ] ; then
        echo "ps2ascii (Ghostscript) ist nicht installiert"
        exit 1
fi

for _datei in ${@}
do
        DATEINAME="$(echo "$(basename ${_datei})" | rev | sed 's/.*[.]//' | rev)"

        pdf2ps ${_datei} ${DATEINAME}.ps
        ps2ascii ${DATEINAME}.ps > ${DATEINAME}.txt && rm -f ${DATEINAME}.ps
done

In einzelne Seiten (mit einer Auflösung von 300 dpi) zerlegen:

# pdf2ps -r300 dokument.pdf dokument_%04d.ps
# ls -1
dokument.pdf
dokument_0001.ps
dokument_0002.ps
dokument_0003.ps
dokument_0004.ps

Auf A4-Format umsetzen:

# ps2eps -f -s a4 dokument_0001.ps

Auf A4-Format umsetzen und dabei um 90 Grad rechts rum drehen:

# ps2eps -f -s a4 -R + dokument_0002.ps

Auf A4-Format umsetzen und dabei um 90 Grad links rum drehen:

# ps2eps -f -s a4 -R - dokument_0003.ps

Auf A4-Format umsetzen und dabei um 180 Grad drehen:

# ps2eps -f -s a4 -R ^ dokument_0004.ps

# ls -1
dokument.pdf
dokument_0001.ps
dokument_0002.ps
dokument_0003.ps
dokument_0004.ps
dokument_0001.eps
dokument_0002.eps
dokument_0003.eps
dokument_0004.eps

A4-hoch im JPEG-Format (verlustbehaftet):

# cat dokument_0001.eps | gs -q -dNOPAUSE -g595x842 -sDEVICE=jpeg -sOutputFile=dokument_0001.jpg

A4-quer im PNG-Format (verlustfrei, hat aber weniger Farben als TIFF):

# cat dokument_0002.eps | gs -q -dNOPAUSE -g842x595 -sDEVICE=png48 -sOutputFile=dokument_0002.png

Diese Seite wieder ins PDF-Format umwandeln:

# gs -dSAFER -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=dokument_0003.pdf -f dokument_0003.ps

A4-quer im TIFF-Format (verlustfrei):

# cat dokument_0004.eps | gs -q -dNOPAUSE -g842x595 -sDEVICE=tifflzw -sOutputFile=dokument_0004.tif

Aus verschiedenen Postscriptdateien oder eps-Dateien kann man auch wieder eine PDF-Datei machen:

# gs -dSAFER -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=dokument_neu.pdf -f dokument_0001.ps dokument_0002.ps dokument_0003.ps

oder

# gs -dSAFER -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=dokument_neu.pdf -f dokument_0001.eps dokument_0002.eps dokument_0003.eps

oder

# gs -dSAFER -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=dokument_neu.pdf -f dokument_*.eps

• http://www.thescripts.com/forum/thread267311.html

# pdf2ps datei.pdf datei.ps
# gs -sDEVICE=jpeg -sOutputFile=datei.jpg datei.ps

-q
-dBATCH
-pA4
-sDEVICE=epswrite
-sDEVICE=tiffg4
-sDEVICE=png
-sDEVICE=jpeg -dJPEGQ=75 -r600 (Qualität:75, DPI:600)

Seit ImageMagick Version 7 heißt das Kommando nicht mehr convert sondern magick. In FreeBSD wird ein SymLink von magick auf convert automatisch angelegt, damit alte Skripte auch weiterhin funktionieren.

Meine nicht repräsentativen Tests haben gezeigt, dass das konvertieren in das AVIF-Format bei einer quality-Angabe von ca. "70", keine Unterschiede zu dem Original mehr sichtbar sind.

> magick original.webp -quality 70 ergebnis.avif

Will man die Dateigröße von einem Bild, mit relativ schlechter Qualität, verkleinern, dann ist der sinnvollste Weg, die Anzahl der Bildpunkte zu reduzieren.

> magick  original.jpg -quality 90 -resize 1760x990 ergebnis.avif

FreeBSD 13.0:

# pkg search -o ImageMagick
# pkg install graphics/ImageMagick7-nox11 graphics/pngwriter
# convert identify -list format

Will man die Unterstützung von HEIC/HEIF, dann muss man es sich aus dem Ports-Tree bauen. - Auch bei Linux (Debian) gibt es diese Unterstützung nicht im regulären Paket.

Die erste Seite aus dem oben zerlegten PDF-Dokument soll hier um 90° links herum gedreht und ins A4-Format gebracht werden.

Diese PostScript-Datei soll mit einer Auflösung von 300x300dpi gelesen werden, das stellt in diesem Fall die Ausgangsqualität dar.

# convert -density 300x300 original.ps -rotate 270 -resize 595x842 ergebnis.png

oder

# convert -density 300x300 original.ps -rotate 270 -repage a4 ergebnis.png

oder

# convert -density 300x300 original.ps -rotate 270 -repage a4 -quality 95 ergebnis.png

Hier wird ein JPEG-Bild, im Originalformat 2479x3508, in eine PNG-Datei ins 595x842-Format (A4) konvertiert:

# convert -size 2479x3508 original.jpg -rotate 270 -resize 595x842 -quality 95 ergebnis.png

Das Ergebnis kann auch eine Postscriptdatei sein:

# convert -density 300x300 original.ps -rotate 270 -repage a4 ergebnis.ps

Auch PDF-Dateien kann man hiermit bauen:

# convert -density 300x300 dokument_0001.ps -density 300x300 dokument_0002.ps -density 300x300 dokument_0003.ps -repage a4 dokument_a4.pdf

So kann man erfahren, was in einer Bilddatei steckt:

# identify dokument_0001.ps
dokument_0001.ps PS 1191x842 1191x842+0+0 16-bit DirectClass 1.448MiB 0.070u 0:00.079

Beispielskript:

bilder_skalieren_png.sh

#!/usr/bin/env bash
 
#
# Dieses Skript skaliert alle Bilder, die im aktuellen Verzeichnis liegen,
# in eine andere Größe.
# Es werden die Ausgabedateien im PNG-Format abgelegt.
#
 
VERSION="v2013082101"
 
#------------------------------------------------------------------------------#
while [ "${#}" -ne "0" ]; do
        case "${1}" in
                -b)
                        unset HOEHE
                        BREITE=${2}
                        shift
                        ;;
                -h)
                        HOEHE=${2}
                        unset BREITE
                        shift
                        ;;
                -d)
                        DENSITY=${2}
                        shift
                        ;;
                *)
                        if [ "$(echo "${1}"|egrep '^-')" ] ; then
                                echo "Der Parameter '${1}' wird nicht unterstuetzt!"
                        fi
                        shift
                        ;;
        esac
done
#------------------------------------------------------------------------------#
if [ -n "${BREITE}" ] ; then
 
        echo "alle Bilder sollen eine einheitliche Breite von ${BREITE} Pixel haben"
 
neuesformat()
{
ZIELFORMAT="$(echo "${BB} ${BH} ${BREITE}" | awk '{print $3"x"$2*$3/$1}')"
}
 
elif [ -n "${HOEHE}" ] ; then
 
        echo "alle Bilder sollen eine einheitliche Hoehe von ${HOEHE} Pixel haben"
 
neuesformat()
{
ZIELFORMAT="$(echo "${BB} ${BH} ${HOEHE}" | awk '{print $1*$3/$2"x"$3}')"
}
 
else
echo "
wenn alle Bilder eine einheitliche Breite haben sollen:
        ${0} -b 1024
 
wenn alle Bilder eine einheitliche Hoehe haben sollen:
        ${0} -h 1080
 
es kann auch die Bildpunktdichte mit angegeben werden:
        ${0} -d 72x72 -h 1080
        ${0} -d 96x96 -h 1080
        ${0} -d 150x150 -h 1080
        ${0} -d 300x300 -h 1080
"
exit 0
fi
 
if [ -z "${DENSITY}" ] ; then
        DENSITY="72x72"
        #DENSITY="300x300"
fi
#------------------------------------------------------------------------------#
### https://www.heins.info/wiki/doku.php?id=dateiformate_konvertieren#mit_imagemagick
# convert -density 300x300 original.ps -resize 595x842 ergebnis.png
 
wandeln()
{
# identify DSCI0001.JPG 
# DSCI0001.JPG JPEG 4320x3240 4320x3240+0+0 8-bit sRGB 5.433MB 0.000u 0:00.007
 
BB="$(identify ${1} | awk '{print $3}' | awk -F'x' '{print $1}')"
BH="$(identify ${1} | awk '{print $3}' | awk -F'x' '{print $2}')"
 
if [ -n "${BB}" -a -n "${BH}" ] ; then
        neuesformat ${DATEINAME}
        echo "${1} -> ${1}_-_${ZIELFORMAT}.png"
        convert -density ${DENSITY} ${1} -resize ${ZIELFORMAT} ${1}_-_${ZIELFORMAT}.png
fi
}
#------------------------------------------------------------------------------#
 
for DATEINAME in $(ls)
do
        if [ -f ${DATEINAME} ] ; then
                wandeln ${DATEINAME}
        fi
done

# convert Datei.pdf Datei.png
# convert -density 72 Datei.pdf Datei.png

# convert -density 100 Datei.pdf Datei.png

# convert -density 300x300 Datei.pdf Datei.png

# identify Bild.jpg
Bild.jpg JPEG 1191x842 1191x842+0+0 16-bit DirectClass 1.448MiB 0.070u 0:00.079
# convert -size 1191x842 Bild.jpg -resize 720x576 -background black -compose Copy -gravity center -extent 720x576 -quality 95 Bild_720x576.png

#!/bin/bash
BILD="${1}"
NEFORMAT="720x576"        # Einheitsformat
BNAME="$(basename ${BILD} | rev | awk '{sub("[.]"," ");print $2}' | rev)"
OFORMAT="$(identify  | awk '{print $3}' || exit 1)"
convert -size ${OFORMAT} ${BILD} -resize ${NEFORMAT} -background black -compose Copy -gravity center -extent ${NEFORMAT} -quality 95 ${BNAME}_${NEFORMAT}.png

so wird das Script angewendet:

# /home/bin/bilder_resize.sh Bild.jpg

Wenn man mit XSane "mehrseitig" einstellt und dazu ein Projekt anlegt, dann wird ein Verzeichnis mit dem Projekt-Namen angelegt.

Dann scannt man alle Seiten ein, die daraufhin in diesem Verzeichnis als PNM-Dateien abgelegt werden.

Wenn diese Seiten im Querformat beschrieben wurden, dann müssen diese PNM-Dateien noch gedreht werden.

So kann man diese PNM-Dateien zu einer mehrseitigen PDF-Datei zusammen bauen:

als erstes in das XSane-Projekt-Verzeichnis wechseln:

> cd ~/xsaneprojekt

PNM → EPS:

> convert image-0001.pnm image-0001.eps

PNM → EPS mit einer Rechtsdrehung:

> convert image-0001.pnm -rotate 90 image-0001.eps

PNM → EPS mit einer Rechtsdrehung und einer Verringerun der Auflösung auf 200dpi, dmit die PDF-Datei nicht zu groß wird:

> convert image-0001.pnm -rotate 90 -density 200x200 image-0001.eps

wenn auf diese Weise alle PNM-Dateien in EPS-Dateien umgewandelt wurden, dann kann man die mehrseitige PDF-Datei aus allen EPS-Dateien bauen:

> convert image-*.eps xsaneprojekt.pdf

Hier ein Skript dafür:

> vi Scan2pdf.sh

#!/bin/bash

#
# PNM-Dateien zu einer mehrseitigen PDF-Datei zusammen bauen
#

#------------------------------------------------------------------------------#
if [ -z "${2}" ] ; then
        echo "${0} 'image-*.pnm' 'Dokument.pdf'"
        exit 1
fi
#------------------------------------------------------------------------------#
### Variablen
#
# A4: 8,268 Zoll x 11,693 Zoll
#

#DPI="-density 72x72"
#DPI="-density 100x100"
DPI="-density 200x200"
#DPI="-density 300x300"

#DREHUNG="-rotate 90"   # rechts rum drehen
#DREHUNG="-rotate 180"  # auf dem Kopf drehen
#DREHUNG="-rotate 270"  # links rum drehen

##FORMAT="-repage a4"
##FORMAT="-repage a5"
##FORMAT="-repage a6"

#------------------------------------------------------------------------------#
for i in ${1}
do
        rm -f ${i}.eps

        echo "convert ${i} ${DREHUNG} ${DPI} ${i}.eps"
              convert ${i} ${DREHUNG} ${DPI} ${i}.eps
done
#------------------------------------------------------------------------------#

rm -f ${2}

echo "convert ${1}.eps ${FORMAT} ${2}"
      convert ${1}.eps ${FORMAT} ${2}

rm -f ${1}.eps
identify ${2} | head -n1
ls -lha ${2}

so könnte man es beispielsweise benutzen (erst die Einstellungen in der Datei nach Wunsch vornehmen, wie "Drehung" bzw. "DPI"):

> cd ~/xsaneprojekt
> .../bin/Scan2pdf.sh 'image-*.pnm' 'xsaneprojekt.pdf'

• http://www.issociate.de/board/post/427260/PDF_to_image.html

(Tex und AbiWord müssen installiert sein)

# abiword --to=latex datei.doc
# latex --interaction=batchmode datei.latex
# dvigif datei.dvi

# wget -F --no-check-certificate https://heins.info/wiki/doku.php?id=vernetzung -O vernetzung.html

Das im folgenden beschriebene Vorgehen wurde an diesem Wiki getestet.

Eine dynamische Seite (in diesem Fall eine "DokuWiki"-Seite) vom Home-Server saugen und als statische HTML-Seiten ablegen, damit man sie auf den gemieteten Webserver hoch laden kann.

Das ist sinnvoll, wenn man nur eine billige Webseite bei einem billigen Web-Hoster gemietet hat, auf der man bestimmte Dinge nicht tun kann, weil dort praktisch nichts installiert wurde.

Dann baut man sich zu Hause seinen Web-Server mit vollem Funktionsumfang auf und konvertiert die dynamischen Seiten dann in statische, die dann ins Internet hochgeladen werden können, oder auch auf einen USB-Stick abgelegt werden können.

# wget -F --no-check-certificate https://www.heins.info/wiki/doku.php?id=vernetzung -O - | sed -e 's#href="/wiki/lib/exe/#href="#' -e 's#<a href=.*id=#<a href="#' -e 's#<img src=".*media=#<img src="#g' -e 's#" class="wikilink#.html" class="wikilink#' -e 's#<a href=".*;media=#<a href="#' > vernetzung.html

Jetzt müssen noch die Bilder ins Verzeichnis kopiert werden.

Beim Dokuwicki könnte man das so machen:

# cp /usr/share/dokuwiki/data/pages/* .

Oder man saugt sie sich auch mit wget.

Dieses Script wurde am 14. September 2013 auf Ubuntu 10.04 erstmals fertiggestellt und am 01. März 2021 auf FreeBSD 12 angepasst und erfolgreich getestet:

# vi wiki2portabel.sh

wiki2portabel.sh

#!/usr/bin/env bash
 
#------------------------------------------------------------------------------#
#
# Dieses Skript liest die verfügbaren seiten aus dem Dateisystem und ruft sie per HTTPS ab.
# Dann werden sie zu lokal aufrufbaren HTML-Dateien konvertiert.
#
#------------------------------------------------------------------------------#
 
VERSION="v2021030100"
 
QUELLE="/home/http/wiki"
ZIEL="/tmp/wiki"
WIKISERVER="192.168.1.1"
 
if [ ! -d "${QUELLE}" ] ; then
        echo "
        Es konnte kein Doku-Wiki-Verzeichnis gefunden werden.
        "
        exit 1
fi
 
rm -fr ${ZIEL}
mkdir -p ${ZIEL}
 
 
### HTML-Dateien ablegen
#
cd ${QUELLE}/data/pages/ && ls *.txt | sed 's/\.txt//' | while read WIKI
do
 
      # <a href="/wiki/doku.php?id=openqrm_-_einrichten_einer_kvm-vm" class="wikilink1" title="openqrm_-_einrichten_einer_kvm-vm">
      # <a href="/wiki/lib/exe/detail.php?id=eine_virtuelle_maschine_anlegen&amp;media=01.png" class="media" title="01.png">
      # <img src="/wiki/lib/exe/fetch.php?w=768&amp;h=600&amp;media=01.png" class="media" alt="" width="768" height="600" /></a>
 
      wget -F --no-check-certificate "https://${WIKISERVER}/wiki/doku.php?id=${WIKI}" -O - | sed \
      -e 's#<link rel="search" href=.*##' \
      -e 's#<link rel="start" href=.*##' \
      -e 's#<link rel="contents" href=.*##' \
      -e 's#<link rel="canonical" href=.*##' \
      -e 's#<link rel="alternate" type=".*##' \
      -e 's#href="/wiki/lib/exe/#href="#' \
      -e 's#<a href=.*id=#<a href="#' \
      -e 's#<img src=".*media=#<img src="#g' \
      -e 's#" class="wikilink#.html" class="wikilink#' \
      -e 's#<a href=".*;media=#<a href="#' \
      -e 's#<link rel="stylesheet" media="all"    type="text/css" href="css.php?s=all&amp;t=default&amp;tseed=[0-9]*" />#<link rel="stylesheet" media="all"    type="text/css" href="all.css" />#g' \
      -e 's#<link rel="stylesheet" media="screen" type="text/css" href="css.php?t=default&amp;tseed=[0-9]*" />#<link rel="stylesheet" media="screen" type="text/css" href="screen.css" />#g' \
      -e 's#<link rel="stylesheet" media="print"  type="text/css" href="css.php?s=print&amp;t=default&amp;tseed=[0-9]*" />#<link rel="stylesheet" media="print"  type="text/css" href="print.css" />#g' \
      -e 's#/wiki/lib/tpl/default/images/favicon.ico#favicon.ico#' \
      -e 's#start&amp;do=backlink#start.html#' \
      -e 's#href="start"#href="start.html"#' \
      > ${ZIEL}/${WIKI}.html
done
 
 
 
 
### CSS-Dateien
#
wget -F --no-check-certificate "https://${WIKISERVER}/wiki/lib/exe/css.php?s=all&amp;t=default&amp;tseed=1274567601" -O /tmp/all.css
cat /tmp/all.css | sed -e 's#}#}³#g' -e 's#(/wiki/lib/images/fileicons/#(#g' -e 's#(/wiki/lib/images/interwiki/#(#g' -e 's#(/wiki/lib/images/#(#g' | tr -s '³' '\n' > ${ZIEL}/all.css
 
wget -F --no-check-certificate "https://${WIKISERVER}/wiki/lib/exe/css.php?t=default&amp;tseed=1274567601" -O /tmp/screen.css
cat /tmp/screen.css | sed -e 's#}#}³#g' -e 's#(/wiki/lib/images/fileicons/#(#g' -e 's#(/wiki/lib/images/interwiki/#(#g' -e 's#(/wiki/lib/images/#(#g' | tr -s '³' '\n' > ${ZIEL}/screen.css
 
wget -F --no-check-certificate "https://${WIKISERVER}/wiki/lib/exe/css.php?s=print&amp;t=default&amp;tseed=1274567601" -O /tmp/print.css
cat /tmp/print.css | sed -e 's#}#}³#g' -e 's#(/wiki/lib/images/fileicons/#(#g' -e 's#(/wiki/lib/images/interwiki/#(#g' -e 's#(/wiki/lib/images/#(#g' | tr -s '³' '\n' > ${ZIEL}/print.css
 
 
### Dateien, auf die in den CSS-Dateien verwiesen wird
#
cat /tmp/all.css /tmp/screen.css /tmp/print.css | sed -e 's#}#}³#g' | tr -s '³' '\n' | sed -e 's#.*(/wiki/##g' -e 's#).*##g' | while read DATEI
do
      if [ -r "${QUELLE}/${DATEI}" ] ; then
              cp ${QUELLE}/${DATEI} ${ZIEL}/
      fi
done
 
 
### eingebettete Bilder ins Ziel-Verzeichniss kopieren
#
cp -a ${QUELLE}/data/media/* ${ZIEL}/
#cp -a ${QUELLE}/lib/tpl/default/images/favicon.ico ${ZIEL}/

Jetzt das Script starten:

# bash wiki2portabel.sh

Wenn das Script gelaufen ist, wird ein Verzeichnis (in diesem Fall ist es "/tmp/wiki") existieren, in dem alle nötigen Dateien für das Wiki im Offline-Betrieb liegen.

Gestartet wird das Wiki dann zum Beispiel so:

# firefox /tmp/wiki/index.html

oder so

# firefox /tmp/wiki/start.html

1. Plugin saugen: http://sites.google.com/site/torisugari/commandlineprint2
2. weil man bei Google keine XPI-Datei hoch laden kann, ist sie als ZIP-Datei hochgeladen worden. Die ZIP-Datei muss jetzt ausgepackt werden, so das man nur noch die XPI-Datei hat.
3. Plugin installieren: Mozilla Browser (Firefox) starten und dann über "Datei" → "Datei öffnen…", dann die XPI-Datei wählen und öffnen.
4. Browser neu starten

# firefox -print https://server.de/seite.php -printmode pdf -printfile seite.pdf

Und jetzt per Script eine Liste abarbeiten lassen.

Als erstes erstellen wir uns eine Liste von URL's:

# vi /tmp/urlliste.txt

https://heins.info/wiki/doku.php?id=vernetzung
http://sites.google.com/site/torisugari/commandlineprint2
http://www.pro-linux.de/news/1/print/15757/native-zfs-unterstuetzung-fuer-linux-vorgestellt.html

Die Liste darf auch noch viel länger sein…

Und jetzt wandeln wir diese URL's in PDF-Dateien um:

#!/bin/sh

QUELLE="/tmp/urlliste.txt"
ZIEL="/tmp"

cat ${QUELLE} | egrep -v '^$' | while read URL
do
      firefox -print ${URL} -printmode pdf -printfile ${ZIEL}/${URL}.pdf
done