Este é um algoritmo usado para afinar imagens em preto e branco, ou seja, imagens de um bit por pixel. Por exemplo, com uma imagem de entrada de:

const testImage1 = [
 '                               ',
 '#########       ########       ',
 '###   ####     ####  ####      ',
 '###    ###     ###    ###      ',
 '###   ####     ###             ',
 '#########      ###             ',
 '### ####       ###    ###      ',
 '###  ####  ### ####  #### ###  ',
 '###   #### ###  ########  ###  ',
 '                               '
];

Ele produz a saída fina:

[ '                               ',
  '########         ######        ',
  '#      #        ##             ',
  '#       #       #              ',
  '#      #        #              ',
  '###### #        #              ',
  '#     ##        #              ',
  '#      #    #   ##    ##   #   ',
  '#       #         ####         ',
  '                               ' ];

Algoritmo

Suponha que os pixels pretos são um e os pixels brancos são zeros. Leve em conta também que a imagem de entrada é um array retangular, de N por M, de uns e zeros. O algoritmo opera em todos os pixels pretos P1 que podem ter oito vizinhos. Os vizinhos estão, na ordem, organizados como: $$\begin{array}{|c|c|c|} \\hline P9 & P2 & P3\\\\ \\hline P8 & \boldsymbol{P1} & P4\\\\ \\hline P7 & P6 & P5\\\\ \\hline \end{array}$$ Obviamente os pixels de borda da imagem não podem ter os oito vizinhos completos.

• Defina $A(P1)$ = o número de transições de branco para preto, ($0 \to 1$) na sequência P2, P3, P4, P5, P6, P7, P8, P9, P2. (Observe o P2 extra no final - é circular).
• Defina $B(P1)$ = o número de vizinhos de pixel preto de P1. ($= \\sum(P2 \ldots P9)$)

Passo 1: Todos os pixels são testados e pixels satisfazendo todas as seguintes condições (simultaneamente) são apenas anotados nesta fase. 1. O pixel é preto e tem oito vizinhos 2. $2 \le B(P1) \le 6$ 3. $A(P1) = 1$ 4. Pelo menos um dos pixels, entre $P2$, $P4$ e $P6$, é branco 5. Pelo menos um dos pixels, entre $P4$, $P6$ e $P8$, é branco Depois de iterar sobre a imagem e coletar todos os pixels satisfazendo todas as condições do passo 1, todos estes pixels que satisfazem as condições são definidos como brancos. Passo 2: Todos os pixels são testados novamente e pixels satisfazendo todas as seguintes condições (simultaneamente) são apenas anotados nesta fase. 1. O pixel é preto e tem oito vizinhos 2. $2 \le B(P1) \le 6$ 3. $A(P1) = 1$ 4. Pelo menos um dos pixels, entre $P2$, $P4$ e $P8$, é branco 5. Pelo menos um dos pixels, entre $P2$, $P6$ e $P8$, é branco Depois de iterar sobre a imagem e coletar todos os pixels satisfazendo todas as condições do passo 2, todos estes pixels que satisfazem as condições são definidos novamente como brancos. Iteração: Se qualquer pixel for definido nessa rodada dos passos 1 ou 2, então todos os passos são repetidos até que nenhum pixels da imagem seja mudado.

Escreva uma rotina que realize o afinamento de Zhang-Suen na image fornecida, um array de strings, onde cada string representa uma única linha da imagem. Na string, # representa um pixel preto e espaço em branco representa um pixel branco. A função deve retornar a imagem fina, usando a mesma representação.

Critérios de Aceitação:

Testes:

• `thinImage` deve ser uma função.
• `thinImage` deve retornar um array.
• `thinImage` deve retornar um array de strings.
• `thinImage(testImage1)` deve retornar uma imagem fina como no exemplo.
• `thinImage(testImage2)` deve retornar uma imagem fina.