Como girar automaticamente uma área de imagem retangular em alguns graus para que sua borda esquerda fique vertical (usando ferramentas de linha de comando como o imagemagick)

Para seu exemplo simples e limpo, você pode fazer o seguinte; usar o imagemagick trimpara remover a maior parte da borda externa, então tentar girar em 1 grau (adicionando um fundo preto correspondente aos pixels recém-adicionados da imagem agora maior), aparar novamente e ver se o tamanho da imagem foi reduzido. Pegue o melhor tamanho reduzido.

file=in.png
convert "$file" -trim out.png
minwidth=$(identify -format '%w' out.png)
minrot=0
for rot in $(seq 1 30)
do      convert out.png -background black -rotate -"$rot" out2.png
        convert out2.png -trim out3.png
        width=$(identify -format '%w' out3.png)
        echo "$rot degrees, width $width"
        if [ $width -lt $minwidth ]
        then    minwidth=$width minrot=$rot
        else    break
        fi
done
echo "choose rotate $minrot for min width $minwidth"
convert out.png -background black -rotate -"$minrot" out2.png
convert out2.png -trim result.png
display result.png

Para a imagem de teste obtive:

1 degrees, width 381
2 degrees, width 375
3 degrees, width 369
4 degrees, width 363
5 degrees, width 355
6 degrees, width 359
choose 5 width=355

Se o quadro real for um pouco menos monocromático que o do exemplo, você pode tentar prefixar a -trimopção com, digamos, -fuzz 15%para obter uma comparação de cores de pixel mais aproximada.

Esta resposta tenta ser rápida usando um recurso -trimpelo qual deixa o deslocamento da nova imagem dentro da tela antiga dentro das informações da nova imagem. Primeiro, fazemos um corte global para obter uma imagem onde: o canto superior do espaço em branco desejado deve encostar no topo da imagem, e o canto mais à esquerda do espaço em branco desejado deve encostar no lado esquerdo da imagem. Este é o retângulo amarelo pontilhado na imagem abaixo.

Repaginamos esta imagem para que a tela tenha o mesmo tamanho da nova imagem.

Uma fatia horizontal fina do topo é tirada (de altura $stripwidthno script abaixo) no arquivo line1.png, que é o retângulo vermelho. Isso é aparado (no arquivo out4.png), como mostrado pelo retângulo azul. O deslocamento com seta %Xda imagem resultante deve ser onde o canto superior foi encontrado. Para obter uma estimativa melhor, metade da largura da imagem aparada ( %w/2) é adicionada a isso (exagerada na imagem abaixo).

Similarmente, uma fatia vertical fina é tomada e aparada. O deslocamento %Yé onde o canto mais à esquerda foi encontrado, com metade da altura %h/2adicionada.

Por exemplo, se o resultado aparado da faixa vermelha line1.pngfor azul out4.png, então identify out4.pngpode ser gerado

out4.png PNG 14x2 387x432+36+0 ...

que diz que a imagem tem 14x2 pixels, de um line1.pngtamanho de tela ( ) de 387x432, com um deslocamento de 36 pixels em x e 0 em y.

Agora temos os comprimentos dos lados opostos e adjacentes do triângulo superior esquerdo. Se calcularmos os graus usando arctan, essa é a rotação necessária para fazer esse triângulo desaparecer, e assim alinhar o canto superior com a borda esquerda.

file=in.png
# fuzz='-fuzz 15%'
stripwidth=2
convert "$file" $fuzz -trim out.png
minwidth=$(identify -format '%w' out.png)

convert out.png +repage -crop ${minwidth}x${stripwidth}+0+0 line1.png
convert line1.png $fuzz -trim out4.png
opp=$(identify -format '0 %X +%w/2' out4.png)

ht=$(identify -format '%h' out.png)
convert out.png +repage -crop ${stripwidth}x${ht}+0+0 line2.png
convert line2.png $fuzz -trim out5.png
adj=$(identify -format '0 %Y +%h/2' out5.png)

minrot=$(echo "scale=2; pi=4*a(1); 
    opp=$opp; adj=$adj; 
    a(opp/adj)*180/pi" |
    bc -l)

convert out.png -background black -rotate -"$minrot" out2.png
convert out2.png $fuzz -trim result.png
display result.png

Note que a()é arctan (em radianos) em bc. O identify -formatusa %w %h %X %Ypara obter a largura, altura, deslocamento x, deslocamento y da imagem aparada na tela original. O extra 0é porque o imagemagick adiciona um +sinal de liderança e bcnão lida com isso.

O resultado foi 5,76 graus, como visto nesta sh -xsaída:

+ convert out.png +repage -crop 387x2+0+0 line1.png
+ convert line1.png -trim out4.png
++ identify -format '0 %X +%w/2' out4.png
+ opp='0 +36 +15/2'
++ identify -format %h out.png
+ ht=432
+ convert out.png +repage -crop 2x432+0+0 line2.png
+ convert line2.png -trim out5.png
++ identify -format '0 %Y +%h/2' out5.png
+ adj='0 +381 +19/2'
++ echo 'scale=2; pi=4*a(1); 
        opp=0 +36 +15/2; adj=0 +381 +19/2; 
        a(opp/adj)*180/pi'
++ bc -l
+ minrot=5.76
+ convert out.png -background black -rotate -5.76 out2.png
+ convert out2.png -trim result.png

A solução a seguir é baseada nas ideias de @meuh. Por favor, vote positivamente nas respostas dele se achar minha solução útil. Primeiro, postarei meu código e, depois, explicarei o que alterei, mencionando apenas as coisas não óbvias.

O código é baseado em algumas suposições que são seguras para as imagens que tenho que processar:

1. A borda esquerda da área branca nas imagens originais não é girada em mais de 5 graus em relação a uma linha vertical.
2. A área branca nas imagens originais tem pelo menos 2000 pixels de altura e 1000 pixels de largura.

#!/usr/bin/bash

file=ScanImage7123.tif
stripwidth=4

convert "$file" -fuzz 20% -trim out.png
width=$(identify -format '%w' out.png)
height=$(identify -format '%h' out.png)

(( wd = (width / 2) ))
(( l1yoff = (height / 10) ))
(( l2yoff = (height - l1yoff) ))

convert out.png +repage -crop ${wd}x${stripwidth}+0+${l1yoff} line1.png
IFS=" x+" read a b x1 d < <(convert -fuzz 50% line1.png -format "%@" info:)

convert out.png +repage -crop ${wd}x${stripwidth}+0+${l2yoff} line2.png
IFS=" x+" read a b x2 d < <(convert -fuzz 50% line2.png -format "%@" info:)

(( a = (x1 - x2) ))
(( b = (l2yoff - l1yoff) ))
rad2deg="57.2957795130823208768"

angle=$(perl -E "say atan2(${a}, ${b}) * ${rad2deg}")

convert out.png -background black -rotate -${angle} out2.png
convert out2.png -fuzz 20% -trim result.png

A ideia aqui é que na verdade não precisamos encontrar os cantos da área branca. Isso é importante, porque encontrar os cantos de forma confiável era impossível para mim, mesmo quando brincava com valores diferentes para stripwidth.

Minhas imagens do mundo real vêm de um scanner, o que significa que as bordas da área branca não são muito nítidas. Isso torna bem difícil encontrar o canto superior. Normalmente, poderíamos encontrar a borda superior da seguinte maneira: após a primeira convertoperação (aparar), vá para a primeira linha de pixels (no topo), caminhe ao longo dela da esquerda para a direita e pare no primeiro pixel branco; então você encontrou o canto.

Isso é praticamente impossível se a área branca já for horizontal, ou quase horizontal, e fica mais difícil quanto menos "nítida" for a borda superior.

Portanto, movi a área (a "linha") que é cortada pela segunda convertoperação para longe da borda superior em um décimo da altura da imagem. Isso garante que temos uma transição horizontal clara e relativamente nítida do preto para o branco naquela linha (nome do arquivo line1.png).

Eu queria evitar ter duas transições horizontais na linha 1 (por exemplo, preto -> branco no lado esquerdo e branco -> preto no lado direito). Isso é simplesmente porque eu não tenho ideia imagemagicke nenhuma pista sobre o que aconteceria na próxima etapa se houvesse mais de uma transição na linha. Portanto, ao cortar a linha, eu uso apenas metade da largura da imagem. [Nota lateral: ainda pode haver várias transições na linha, dependendo do conteúdo da área branca (por exemplo, texto preto), mas isso não impôs problemas em meus primeiros testes.]

A terceira convertoperação gera algo como 0x10+45+0. A parte 0x10denota as dimensões da transição mencionada acima, +45é a Xcoordenada onde a transição começa. Este é o valor que buscamos; a readconstrução o salva em x1.

O mesmo método é aplicado para a segunda "linha" (nome do arquivo line2.png), que é cortada um décimo da altura da imagem a partir da parte inferior da imagem (quarta convertoperação). Na próxima linha (quinta convertoperação), a Xcoordenada da transição do preto para o branco na linha 2 é salva em x2.

Agora podemos calcular a distância horizontal e vertical entre as duas transições na linha 1 e na linha 2 e, a partir dessas distâncias, podemos calcular o ângulo de rotação.

Usei Perl para executar esse cálculo porque bcele não fornece a atan2()função, que eu claramente prefiro nesses casos por sua capacidade de lidar com situações em que a distância horizontal ou vertical (ou mesmo ambas) é 0.

O resto deve ser autoexplicativo.