Processar em lote imagens de documentos para parecer um fax

Question

Digamos que eu tenha uma foto ou digitalize um documento de texto, possivelmente com algum fundo de marca d'água de baixo contraste. Se é uma foto, além disso para a marca d'água haverá gradientes de brilho da iluminação e, possivelmente, da folha de papel que não está plana devido a dobras.

Eu quero pós-processar essas fotos com o imagemagick para parecer um fax, ou seja, converter a imagem para preto / branco monocromático corrigindo variações locais de brilho. A opção normal -threshold será não funciona, já que

1. Ele não detecta automaticamente o nível de brilho necessário para cada foto.
2. Devido aos gradientes de brilho, o texto em uma parte da imagem pode ser mais brilhante do que o fundo em outra parte tal que para qualquer limite global dado, algum texto será perdido.

Aplicativos Cam-Scanner em smartphones geralmente fornecem um documento em preto / branco opção que corrige esses gradientes de cor e calcula um valor razoável primeiro palpite para o valor limite, isso seria suficiente para o lote em processamento.

Eles não ajudam quando já tenho a imagem bruta no PC, embora eu pudesse, em teoria, enviá-los para o smartphone e importá-los - é altamente impraticável, especialmente para um grande número de imagens.

O imagemagick ou algum outro software capaz de processamento em lote (preferencialmente código aberto) suporta tal conversão?

    

Answer 1

Você pode usar os Métodos de composição matemática do Imagemagick para obter esses resultados. Divide_src [1] em particular, pois removeria quaisquer gradientes, vinhetas, sombras indesejadas.

Então, um -normalize e um -threshold devem fazer o resto.

convert $input -colorspace gray ( +clone -blur 15,15 ) -compose Divide_Src -composite -normalize -threshold 80% $output

Aqui está o meu resultado:

Vocêpodequerermelhorarolimiteparaobterosmelhoresresultados.

Dependendodosistemaoperacionalquevocêestáexecutando,vocêpodeterqueescapardoscolchetes:"\ (" e "\)".

Quanto ao processamento em lote, eu usaria um loop "for" no bash ou no Cygwin novamente, dependendo do SO:

for file in test/*; do convert $file -colorspace gray ( +clone -blur 15,15 ) -compose Divide_Src -composite -normalize -threshold 80% result/'basename $file'; done

No entanto, há outra ferramenta de linha de comando que você pode querer verificar chamada mogrify [2] para processamento batch in-line ou específico -path .

Para mais informações e possíveis resultados diferentes, siga [3] e [4].

[1]: www.imagemagick.org/Usage/compose/#divide

[2]: www.imagemagick.org/script/mogrify.php

[3]: staff.washington.edu/corey/camscan/

[4]: www.imagemagick.org/Usage/photos/#color-in

    

Answer 2

Atualizar Formulários atualizados dos scripts agora são hospedados como "gists" [1] [2]

Com base na resposta my matthewd, escrevi scripts que automatizam o processo como pretendido para digitalizações com um contraste razoável. Os scripts usam pdfimages do poppler, convert e pdftk do ImageMagick.

imagemagick-scan-pdf-to-mono.sh (depende do segundo script; a saída pode ser rotacionada, o que pode ser corrigido executando pdftk FILE.pdf cat 1-endW output OUT.pdf . A direção da rotação pode ser alterada usando 1-endE em vez de 1-endW )

#!/usr/bin/env bash
# -*- mode: sh; coding: us-ascii-unix -*-

# source libstacktrace || true
# set -e -u -E

MANUAL="
Usage: $0 [options] INPUT OUTPUT

Converts a scan-pdf (assuming one image per page) to monochrome.

-f INT, --from-page INT
    Process only pages with page number >= INT

-t INT, --to-page INT
    Process only pages with page number <= INT

-P, --parallel INT
    Process INT pages in parallel each. 

-v, --verbose / +v, --noverbose
    Enables/Disables verbose reporting.

-h, -?, --help
    Prints this message

"

vecho(){ $VERBOSE && echo "$@"; }

######### COMMAND LINE PARSING #######################################

declare VERBOSE=false
declare ARGS=()
declare PAGE_LIMIT_LOW=""
declare PAGE_LIMIT_HIGH=""
declare PARALLEL=1

## Print manual
if [[ $# -eq 0 ]]; then
    echo "$MANUAL"
    exit 1
fi

## Getopt-style consumption of arguments ##
##
## Don't forget "shift", don't delete "--" and "*" cases.
while [[ $# -gt 0 ]]; do
    case "$1" in
    -h|-\?|--help)
        echo "$MANUAL"
        exit 0
        shift ;;
    -v|--verbose)
        VERBOSE=true
        shift ;;
    +v|--no-verbose)
        VERBOSE=false
        shift ;;
    -f|--from-page)
        PAGE_LIMIT_LOW="-f $2"
        shift 2 ;;
    -t|--to-page)
        PAGE_LIMIT_HIGH="-l $2"
        shift 2 ;;
    -P|--parallel)
        PARALLEL=$2
        shift 2 ;;
    --)
        shift
        break ;;
    *) 
        ARGS[${#ARGS[@]}]="$1"
        shift ;; 
    esac
done

## Consume stuff remaining after -- ##
while [[ $# -gt 0 ]]; do 
    ARGS[${#ARGS[@]}]="$1"
    shift
done

## Note that ${ARGS[@]} is considered unbound if it is empty!

INFILE=$(readlink -m "${ARGS[0]}") 
OUTFILE=$(readlink -m "${ARGS[1]}")
TMPDIR=$(mktemp -d)

vecho "Using work directory '$TMPDIR'."
cd "$TMPDIR"
vecho "Extracting images from '$INFILE'..."

## Cannot be parallelized, file-locking issue. 

cmd="pdfimages -j $PAGE_LIMIT_LOW $PAGE_LIMIT_HIGH $(printf %q "$INFILE") page"
# vecho "$cmd"
eval "$cmd" || true

find -name "page-*" -and -not -name "page-*-mono*" \
    | xargs -P $PARALLEL -I FILE sh -c "
      imagemagick-scan-to-mono.sh FILE FILE-mono.pdf \
         && { if $VERBOSE; then echo Finished file 'FILE'; fi; }
      rm FILE
    "

vecho "Assembling PDF file '$OUTFILE'..."
pdftk page-*-mono.pdf cat output out.pdf 
mv out.pdf "$OUTFILE"
rm page-*-mono.pdf
rmdir "$TMPDIR" || ls -l

imagemagick-scan-to-mono.sh

#!/usr/bin/env bash
# -*- mode: sh; coding: us-ascii-unix -*-

source libstacktrace || true
set -e -u -E

MANUAL="
Usage: $0 INFILE OUTFILE

Takes a document scan INFILE (an image) and produces a monochromatized
output file version.

"

if [[ "${1:-}" = "-?" ]] || [[ "${1:-}" = "-h" ]] || [[ "${1:-}" = "--help" ]]; then 
    echo "$MANUAL"
    exit 0
fi

BLURRADIUS="20"
INFILE="$(readlink -m "$1")"
OUTFILE="$(readlink -m "$2")"
TMPDIR="$(mktemp -d)"
cd "$TMPDIR"

convert "$INFILE" -colorspace Gray 01.png
convert 01.png -blur "${BLURRADIUS}x${BLURRADIUS}" 02.tif
convert 01.png 02.tif -compose Divide_Src -composite 03.tif 
convert 03.tif -threshold 90% -type bilevel -compress group4 "$OUTFILE"

rm 01.png 02.tif 03.tif
rmdir "$TMPDIR"