Zhang-Suen thinning algorithm: Difference between revisions

The algorithm operates on all black pixels P1 that can have eight neighbours. The neighbours are, in order, arranged as:

# Use the routine to thin the following image and show the output here on this page as either a matrix of ones and zeroes, an image, or an ASCII-art image of space/non-space characters.

00000000000000000000000000000000</pre>"

<langsyntaxhighlight AutoHotkeylang="autohotkey">FileIn := A_ScriptDir "\Zhang-Suen.txt"

}</langsyntaxhighlight>

if(i!=0 &&|| j!=0)

sum+= (imageMatrix[row+i][col+ij]==imagePixel);

//fclose(inputP);

<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.string, std.functional,

}</langsyntaxhighlight>

ELENA 36.2x :

<langsyntaxhighlight lang="elena">import system'collections.;

import system'routines.;

import extensions.;

import extensions'routines.;

" ").};

charmatrix extension zhangsuenOp : Matrix<CharValue>

$proceed : (r :, c :, toWhite :, firstStep)

[{

[{ ^ false ].};

int nn := self .numNeighbors(r,c).;

[{ ^ false ].};

if(self .numTransitions(r,c) != 1)

[{ ^ false ].};

ifnot (self .atLeastOneIsWhite(r,c,firstStep .iif(0,1)))

[{ ^ false ].};

toWhite.append(new append:{ x = c.; y = r.; }.);

^ true.

]}

numNeighbors :(r : ,c)

[{

int count := 0.;

0for till(nbrsint lengthi := 0; i < nbrs.Length - 1); do(:i += 1)

[{

if (self[r + nbrs[i][1]][c + nbrs[i + 1][0]] == $35)

[{ count :+= count + 1. ].}

].};

^ count.;

]}

numTransitions : (r : ,c)

[{

int count := 0.;

0for till(nbrsint lengthi := 0; i < nbrs.Length - 1); do(:i += 1)

[{

[{

[{

count := count + 1.

].}

].}

].};

^ count.

]}

atLeastOneIsWhite : (r :, c :, step)

[{

int count := 0.;

var group := nbrGroups[step].;

0for(int i till:= 0; i < 2; do(:i += 1)

[{

for(int j := 0; j < till(group[i].Length; length) seek(:j += 1)

[{

var nbr := nbrs[group[i][j]].;

[{ count := count + 1.; ^$break; true ].};

}

].^ count > 1

}

] thinImage()

{

boolvar firstSteptoWhite := false.new List();

[{

hasChanged := false.;

firstStep := firstStep not.Inverted;

1 tillit.forEach::(self rows - 1ch){ doconsole.print(:rch," ") }

[}

charmatrixMatrix<CharValue> grid := MatrixSpace::class Matrix<CharValue>.load(new

rowsint Rows = image length.Length;

columnsint Columns = image[0] length.Length;

getAt at(int: i, int: j)

= image[i][j].;

}.);

grid thinImage.thinImage();

grid print.print();

console readChar.readChar()

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

# # # # # # # # #

# # # # #

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

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

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

<langsyntaxhighlight lang="elixir">defmodule ZhangSuen do

ZhangSuen.thinning(str, ?1)</langsyntaxhighlight>

With F90 came standardisation of a variety of array manipulation facilities. Since the image array is to be inspected as a whole then adjusted rather than adjusted step-by-step as it is inspected, the first thought was to employ the special facility of the FOR ALL statement, which is that in an expression such as <langsyntaxhighlight Fortarnlang="fortarn">FOR ALL (i = 2:n - 1) A(i) = (A(i - 1) + A(i) + A(i + 1))/3</langsyntaxhighlight> all right-hand-side expressions will be evaluated with the original values of the array, while in the less special array assignment <langsyntaxhighlight Fortranlang="fortran">A(2:N - 1) = (A(1:N - 2) + A(2:N - 1) + A(3:N))/3</langsyntaxhighlight> as in the case of the equivalent DO-loop, the processing will be with a mixture of old and new values as the loop proceeds.

So, that suggests something like <langsyntaxhighlight Fortranlang="fortran"> FOR ALL (I = 2:N - 1, J = 2:M - 1)

WHERE(DOT(I,J) .NE. 0) DOT(I,J) = ADJUST(DOT,I,J)</langsyntaxhighlight>

Alas, such a syntax form is not accommodated. However, F90 also introduced the ability to define and use compound data types, such as the type PLACE as used below. It is not possible to define a type of a special, recognised form, such as say "SUBSCRIPT LIST" that can be used as dreamt of above, so the components are just ordinary variables. Two ordinary arrays could be used, one for each of the two subscripts, or a compound type could be devised in a hint towards self-documentation. Thus, <langsyntaxhighlight Fortranlang="fortran"> DOT(WHACK(1:WHACKCOUNT).I,WHACK(1:WHACKCOUNT).J) = 0</langsyntaxhighlight>

<langsyntaxhighlight Fortranlang="fortran"> MODULE ZhangSuenThinning !Image manipulation.

END PROGRAM POKE </langsyntaxhighlight>

<langsyntaxhighlight lang="go">package main

}</langsyntaxhighlight>

<langsyntaxhighlight lang="groovy">def zhangSuen(text) {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="groovy">def small = """\

}</langsyntaxhighlight>

<langsyntaxhighlight Haskelllang="haskell">import Data.Array

main = mapM_ (putStrLn . showBWArray . thin . toBWArray) [sampleExA, sampleExB]</langsyntaxhighlight>

<langsyntaxhighlight lang="j">isBlackPx=: '1'&=;._2 NB. boolean array of black pixels

neighbrs=: adverb define 1 :'(1 1 ,: 3 3)&(u;._3)' NB. applies verb u to neighbourhoods

zhangSuen=: [: toImage [: step2@step1^:_ isBlackPx</langsyntaxhighlight>

<langsyntaxhighlight lang="j">zhangSuenX=: verb define

)</langsyntaxhighlight>

<langsyntaxhighlight lang="j">toASCII=: ' #' {~ '1'&=;._2 NB. convert to ASCII representation

</langsyntaxhighlight>

<langsyntaxhighlight lang="java">import java.awt.Point;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="javascript">function Point(x, y) {

ZhangSuen.main(null);</langsyntaxhighlight>

<langsyntaxhighlight lang="scala">// version 1.1.2

}</langsyntaxhighlight>

<langsyntaxhighlight lang="lua">function zhangSuenThin(img)

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<langsyntaxhighlight Mathematicalang="mathematica">nB[mat_] := Delete[mat // Flatten, 5] // Total;

FixedPoint[iter, dat]</langsyntaxhighlight>

=={{header|Perl 6Nim}}==

my \v Bit = +@lines;0..1

=={{header|PhixPerl}}==

<syntaxhighlight lang="pl/i">zhang: procedure options (main); /* 8 July 2014 */

end zhang;</langsyntaxhighlight>

<langsyntaxhighlight lang="python"># -*- coding: utf-8 -*-

print('\nTo thinned:\n%s' % toTxt(after))</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">#lang racket

(read-display-thin-display-image e.g.-image))</langsyntaxhighlight>

<langsyntaxhighlight lang="rexx">/*REXX program thins a NxM character grid using the Zhang-Suen thinning algorithm.*/

p6=@.rp.c\==white; p7=@.rp.cm\==white; p8=@.r.cm\==white; p9=@.rm.cm\==white; return</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">class ZhangSuen

ZhangSuen.new(task_example, "1")</langsyntaxhighlight>

<langsyntaxhighlight lang="ruby">class ZhangSuen(str, black="1") {

ZhangSuen.new(text, black: "1").display</langsyntaxhighlight>

<langsyntaxhighlight lang="tcl"># -*- coding: utf-8 -*-

puts [string map {1 @ 0 .} [join [zhang-suen $data] \n]]</langsyntaxhighlight>