 Research
 Open Access
 Published:
A novel bitquadbased Euler number computing algorithm
SpringerPlus volume 4, Article number: 735 (2015)
Abstract
The Euler number of a binary image is an important topological property in computer vision and pattern recognition. This paper proposes a novel bitquadbased Euler number computing algorithm. Based on graph theory and analysis on bitquad patterns, our algorithm only needs to count two bitquad patterns. Moreover, by use of the information obtained during processing the previous bitquad, the average number of pixels to be checked for processing a bitquad is only 1.75. Experimental results demonstrated that our method outperforms significantly conventional Euler number computing algorithms.
Background
The topological properties of binary images are very useful features in the fields of pattern recognition and computer vision. Among others, the Euler number of a binary image, which is defined as the difference between the number of connected components and that of holes in the image, is one of the most important topological properties (Gonzalez and Woods 2008). The Euler number of a binary image will not change when the image is stretched, flexed or rotated. Therefore, the Euler number has been used in many applications: processing cell images in medical diagnosis (Hashizume et al. 1990), document image processing (Srihari 1986), shadow detection (Rosin and Ellis 1995), reflectancebased object recognition (Nayar and Bolle 1996), and robot vision (Horn 1986). Moreover, the Euler number is the most clinically useful feature for discriminating many cervical disorders (Pogue et al. 2000).
In the past decades of years, many algorithms have been proposed for computing the Euler number of a binary image. For example, there are skeletonbased algorithm (DiazdeLeon and SossaAzuela 1996), which calculates the Euler number by use of the number of terminal points and the number of three edge points in the corresponding skeleton image; bitquadbased algorithm proposed by Gray (1971), which calculates the Euler number by counting certain 2 × 2 pixel patterns called bitquads, and is adopted by the famous commercial image processing tools MATLAB (Thompson and Shure 1995). There are also runbased algorithm (Bishnu et al. 2005), which calculates the Euler number by use of the numbers of runs and the neighboring runs in the image, and labelingbased algorithm proposed by He et al. (2013), which calculates the Euler number by labeling connected components and holes in the image. Recently, an improved bitquadbased algorithm was proposed (Yao et al. 2014), which reduces the number of pixels to be checked for processing a bitquad from 4 to 2. For convenience, we denote the algorithms proposed in Ref. (Gray 1971), Ref. (Bishnu et al. 2005), Ref. (He et al. 2013) and Ref. (Yao et al. 2014) as GRAY algorithm, RUN algorithm, HCS algorithm and IGRAY algorithm, respectively.
On the other hand, there are also parallel algorithm (Chiavetta and Gesu 1993), hardware algorithm (Dey S. et al. 2000), and algorithms for images with quadtree represented formats (Dyer 1980), (Samet and Tamminen 1985). In recent years, other algorithms have been proposed for computing the Euler number in a binary image. For example, SossaAzuelal proposed the algorithm for computing Euler number based on a vertex codification (SossaAzuelal et al. 2013), and he also proposed an alternative algorithm in (SossaAzuela et al. 2014). Yao (2015) improve the Euler number computing algorithm based on runs and neighboring runs. He and Chao (2015) proposed an algorithm for labeling connectedcomponent and computing Euler number simultaneously.
This paper presents a novel bitquadbased Euler number computing algorithm. Based on graph theory, instead of counting ten bitquad patterns in conventional bitquadbased algorithms, our algorithm only needs to count two bitquad patterns for Euler number computing. Moreover, by use of the information obtained during processing the previous bitquad similar as in the IGRAY algorithm, the average number of pixels to be checked for processing a bitquad is reduced to 1.75, which leads to more efficient processing. Experimental results showed that our algorithm is much more efficient than conventional Euler number computing algorithms on various kinds of images.
The rest of this paper is organized as follows. In “Reviews of related conventional Euler number computing algorithms”, we review related conventional Euler number computing algorithms. We propose our algorithm in “Our proposed algorithm”, present experimental results in “Experimental results”, and make a discussion in “Discussion”. Lastly, we give our conclusion in “Conclusion”.
Reviews of related conventional Euler number computing algorithms
For an M × Nsize binary image, we use p(x, y) to denote the pixel at (x, y), where 1 ≤ x ≤ M, 1 ≤ y ≤ N. As in most image processing algorithms, we assume that the object (foreground) pixels and background pixels in a given binary image are represented by 1 and 0 respectively, and all pixels on the border of an image are background pixels. Moreover, we only consider 8connectivity in this paper.
GRAY algorithm
The GRAY algorithm (Gray 1971) for calculating the Euler number of a binary image is based on counting certain 2 × 2 pixel patterns called bitquads. While computing the Euler number of a binary image, it needs to scan the image from left to right and from top to bottom. In the scanning, each pixel and other three pixels in the corresponding bitquad need to be checked for finding the patterns of the bitquad shown in Fig. 1. For example, for the pixel p(x, y) in the image, it checks whether the corresponding bitquad, i.e., \(\left[ {\begin{array}{*{20}c} {\rm{{p}(x}  1, \rm{y}  1)} & {\rm{p(x, y}  1)} \\ {\rm{{p}(x}  1, \rm{y})} & {\text{p(x, y)}} \\ \end{array} } \right]\), is one of patterns P _{1}, P _{2}, and P _{3}. When the scanning is completed, we can obtain the numbers of patterns P _{1}, P _{2}, and P _{3}. Let N _{1}, N _{2}, and N _{3} be the numbers of patterns P _{1}, P _{2}, and P _{3} in the image, respectively, then, the Euler number of the image, denoted as E, can be calculated by the following formula.
Obviously, for processing a pixel, it will take four pixel accesses in a bitquad in the GRAY algorithm. Thus, for calculating the Euler number of an M × Nsize binary image, it will take 4 × M × N pixel accesses in total.
RUN algorithm
The RUN algorithm (Bishnu et al. 2005) calculates the Euler number by use of the number of runs and the number of neighboring runs in the given image.
A run is defined to be a maximal sequence of consecutive object pixels in a row. A run R _{1} is said to be a neighboring run of another run R _{2} if there is at least a pixel in R _{1} such that it is 8connected with a pixel in R _{2}. For example, in Fig. 2, there are three runs in the first row, two runs in the second row and three neighboring runs marked by black oval shape between two rows. We denote the numbers of runs and neighboring runs as R and O in the given image, respectively.
Having counted all runs and neighboring runs in the given image, the Euler number of the image can be calculated by the following formula.
HCS algorithm
The HCS algorithm (He et al. 2013) calculates the Euler number of a binary image according to the definition of the Euler number:
where C is the number of the connected components, and H is that of the holes in the image, respectively.
For calculating C and H, this algorithm extended the labeling algorithm proposed in Ref. (He et al. 2010) to label connected components and holes in the binary image simultaneously. At any moment in the raster scan, all provisional labels assigned to an 8connected component or a 4connected hole in the processed area of the image are combined in an equivalent label set, respectively. Thus, after the raster scan, all provisional labels assigned to a connected component or a hole in the image will be combined in an equivalent label set, respectively. Then, by counting the number of the equivalent label sets corresponding to connected components and that for holes, we can obtain the number of connected components, i.e., C, and that of holes, i.e., H, respectively.
IGRAY algorithm
The IGRAY algorithm (Yao et al. 2014) is an improvement on the GRAY algorithm. It also needs to process all bitquads in the given image and count the number of the special bitquad patterns in the same way as in the GRAY algorithm. However, by use of the alreadyknown information obtained during processing the previous pixel, it reduces the number of pixels necessary to be checked for processing a bitquad from 4 to 2.
Our proposed algorithm
As one of topological properties, the Euler number of a binary image can also be calculated according to graph theory. Chen and Yan proposed a graphbased algorithm for calculating the Euler number of a binary image for 4connectivity (Chen and Yan 1988) by counting all vertices, edges and faces in the graph corresponding to the image. In this section, we first introduce how to use graph theory to calculate the Euler number of a binary image for 8connectivity. Then, we show that only two kinds of bitquad patterns need to be considered for calculating the Euler number.
In order to use graph theory to calculate the Euler number of a binary image, we construct a square graph corresponding to the image. To do that, we take all object pixels in the image as vertices and add an edge between two object pixels if and only if they are 8connected neighbors for each other unless the edge crosses with another edge. For example, for the given image shown in Fig. 3a, according to the constructing method, the vertices and edges can be added as in Fig. 3b. Thus, we can obtain a square graph corresponding to the image as shown in Fig. 3c.
Euler’s theorem in graph theory can be described as follows (West 2001).
Euler’s theorem
If G is a square graph, v, e, r and C are the numbers of vertices, edges, squares and the connected components in G, respectively. Then, v − e + r = C + 1.
In Euler’s theorem, the squares in graph G include holes, basic faces and an infinite square outside of G. Let H and s be the number of holes and basic faces in graph G, respectively. Accordingly, r = H + s + 1. Then we have v − e + (H + s + 1) = C + 1. Thus, the Euler number E can be represented as:
In this way, we can calculate the Euler number of a binary image by use of the numbers of vertices, edges and basic faces in its corresponding graph. Notice that in the case of 8connectivity, the number of basic faces s in the formula (4) refers to the number of basic rightangled triangle faces.
In practice, when using the formula (4) to calculate the Euler number of a binary image, we can count the number of vertices, edges, and basic faces without constructing a corresponding square graph but by checking all bitquads in the given image.
Obviously, the number of vertices in the corresponding graph is equal to the number of object pixels in the image. For a bitquad shown in Fig. 4, pixel p(x, y) is said to be the representative pixel of the bitquad. For convenience, a bitquad with q as the representative pixel is denoted as B(q). It is obvious that only if pixel p(x, y) is an object pixel, the number of vertices will be increased by 1. Notice that the vertex corresponding to each of other object pixels in the bitquad, says, t, has been considered when processing the bitquad B(t).^{Footnote 1}
On the other hand, for calculating the number of new edges in the bitquad, we should consider whether there are edges between p(x, y) and p(x, y − 1), p(x, y) and p(x − 1, y), p(x, y) and p(x − 1, y − 1), and p(x − 1, y) and p(x, y − 1), respectively. Notice that whether there are edges between p(x − 1, y) and p(x − 1, y − 1), and p(x − 1, y − 1) and p(x, y − 1) have already been considered when processing B(p(x − 1, y)) and B(p(x, y − 1)), respectively. Furthermore, in the case where both edges p(x, y) and p(x − 1, y − 1), and p(x − 1, y) and p(x, y − 1) might exist, only one should be considered. Because there is an edge between p _{1} and p _{2} if and only if p _{1} and p _{2} are object pixels, the rules for calculating the number of edges can be shown as follows, where e(u, v) denotes the edge between object pixels u and v.

a.
If p(x, y) is a background pixel, no edge between p(x, y) and p(x, y − 1), between p(x, y) and p(x − 1, y), and between p(x, y) and p(x − 1, y − 1). On the other hand, when and only when both p(x − 1, y) and p(x, y − 1) are object pixels, the edge e(p(x − 1, y), p(x, y − 1)) should be counted (Fig. 5a);

b.
If p(x, y) is an object pixel, in the case where p(x − 1, y) and p(x, y − 1) are object pixels and p(x − 1, y − 1) is a background pixel (Fig. 5b), the three edges e(p(x, y), p(x − 1, y)), e(p(x, y), p(x, y − 1)), and e(p(x − 1, y), p(x, y − 1)) should be counted; in the other cases, for each object pixel q among pixels p(x − 1, y), p(x, y − 1) and p(x − 1, y − 1), an edge e(p(x, y), q) should be counted (Fig. 5c).
As for calculating the number of basic rightangled triangle faces in the bitquad, we only need to check the number of object pixels in the bitquad. The number of basic rightangled triangle faces will be two if all pixels in the bitquad are object pixels (Fig. 6a), and one if there are three object pixels (Fig. 6b–e). Otherwise, no basic rightangled triangle face exists.
When all bitquads in the given image are processed, we can obtain the number of vertices, edges and basic rightangled triangle faces in the corresponding graph, and calculate the Euler number of the image by use of formula (4) easily.
However, calculating the Euler number of a binary image by counting the numbers of vertices, edges and faces directly will be inefficient. In order to do this work more efficiently, we analyze all 16 patterns of a bitquad. For each pattern, according to the above calculating methods, we can obtain the increments of the numbers of vertices, edges and faces, and the Euler number, which are denoted by ∆v, ∆e, ∆s, and ∆E, respectively, where ∆E = ∆v − ∆e + ∆s, as shown in Table 1.
According to Table 1, when processing a bitquad shown in Fig. 7a, the Euler number will increase by 1 only when it is pattern Q _{2}, and will decrease by 1 only if it is either pattern Q _{7} or pattern Q _{8}. Obviously, the conditions for a bitquad to be pattern Q _{2} are that the representative pixel is object pixel and all other pixels in the bitquad are background pixels. On the other hand, the conditions for a bitquad to be patterns Q _{7} or Q _{8}, which can be derived by use of the Karnaugh map (Karnaugh 1953) shown in Fig. 7b, are that p(x − 1, y − 1) is a background pixel, and p(x, y − 1) and p(x − 1, y) are object pixels. Notice that it does not matter whether the representative pixel p(x, y) is an object pixel or not. Therefore, we can combine the two patterns Q _{7} and Q _{8} to one pattern Q _{ c }, as shown in Fig. 8. Thus, let W _{2} and W _{ c } be the numbers of Q _{2} and Q _{ c } in the given image, respectively, we can use the following formula to calculate the Euler number of the image.
Now we introduce how to check whether a bitquad is a pattern of Q _{2} or Q _{ c } when processing the given image in the raster scan.
If p(x − 1, y − 1) is an object pixel, the current bitquad will be neither Q _{2} nor Q _{ c }, so we can skip the bitquad and go to process the next bitquad.
If p(x − 1, y − 1) is a background pixel, we need to check other pixels in the bitquad. Because p(x − 1, y) is either 0 or 1, there are two states as shown in Fig. 9.
For state S _{1}, we need to check both pixel X and pixel Y. There are following three cases: (1) if pixel X is 1, the current bitquad and the next bitquad to be processed will be none of patterns Q _{2} and Q _{ c }, we do nothing else for the current bitquad and skip the next bitquad over; (2) if both pixel X and pixel Y are 0, the current bitquad will be none of patterns Q _{2} and Q _{ c }, then we go to process the next bitquad, which obviously will be a case of state S _{1} (Fig. 9a); (3) if pixel X is 0 and pixel Y is 1, the current bitquad is pattern Q _{2}, thus, W _{2} increases by 1, then we go to process the next bitquad, which will be a case of state S _{2} (Fig. 9b).
For state S _{2}, we also need to check pixel X and pixel Y. There are the following three cases: (1) if pixel X is 1, the current bitquad is pattern Q _{ c }, thus, W _{ c } increases by 1. At the same time, we know the next bitquad will be none of patterns Q _{2} or Q _{ c }, so we can skip the next bitquad over; (2) if both pixel X and pixel Y are 0, the current bitquad will be none of patterns Q _{2} and Q _{ c }, then we go to process the next bitquad, which will be a case of state S _{1}; (3) if pixel X is 0 and pixel Y is 1, the current bitquad will be none of patterns Q _{2} or Q _{ c }, then we go to process the next bitquad, which will be a case of state S _{2}.
After processing all bitquads in the given image, we can obtain the numbers of the patterns Q _{2} and Q _{ c }, i.e., W _{2} and W _{ c }, then, we can calculate the Euler number by use of the formula (5).
The pseudo codes of our algorithm can be shown as follows.
Experimental results
Images used for evaluating the algorithms were composed of artificial images (including 41 noise images and 4 specialized pattern images), 50 natural images obtained from the Standard Image Database (SIDBA) developed by the University of Tokyo^{Footnote 2} and the image database of the University of Southern California,^{Footnote 3} 7 texture images downloaded from the ColumbiaUtrecht Reflectance and Texture Database,^{Footnote 4} and 25 medical images obtained from a medical image database of the University of Chicago.
In the experiments, we compared our algorithm with the GRAY algorithm, the RUN algorithm, the HCS algorithm, and the IGRAY algorithm. All algorithms used for our comparison were implemented in the C language on a PCbased workstation (Intel Core i53470 CPU@3.20 GHz, 4 GB Memory, Ubuntu Linux OS), and compiled by the GNU C compiler (version 4.2.3) with the option –O. All experimental results presented in this section were obtained by averaging of the execution time for 5000 runs.
Execution time versus the density of an image
Because connected components in noise images have complicated geometric shapes and complex connectivity, severe evaluations of algorithms can be performed with these images. 41 noise images with a size of 512 × 512 pixels, which were generated by thresholding of the images containing uniform random noise with 41 different threshold values from 0 to 1000 in steps of 25, were used for testing the execution time versus the density of the foreground pixels^{Footnote 5} in an image. The results are shown in Fig. 10. We can find that our algorithm is much better than the GRAY algorithm for all images, is better than the HCS algorithm for all images except for the images whose densities are over 97 %, and is also much better than the RUN algorithm and the IGRAY algorithm for all images whose densities are over 5 %.
Comparisons in terms of the maximum, mean, and minimum execution times on various kinds of real images
In this test, all the 50 natural images, 25 medical images, 7 texture images, and 4 artificial images with specialized shape patterns (sawtoothlike, checkerboardlike, stairlike, and honey comblike connected components) were used for evaluating the algorithms. The resolution of all of these images is 512 × 512 pixels. The results are shown in Table 2.
From Table 2, for all types of images, our algorithm is much more efficient than both of the GRAY algorithm and the RUN algorithm for all of the minimum time, the average time and the maximum time. Compared to the IGRAY algorithm and the HCS algorithm, our algorithm is more efficient than either of the two algorithms for the average time and the maximum time. In fact, for the images used in this test, our algorithm is better than any of the other algorithms in comparison except for one texture image. The execution time (ms) for the selected six images are illustrated in Fig. 11, where the object pixels are displayed in black.
Discussion
Other groups of patterns for calculating the Euler number
According to the analysis in “Our proposed algorithm”, we can calculate the Euler number of a binary image by the numbers of the bitquad patterns in the image shown in Fig. 12a. Because the Euler number of a binary image will not change when the image is rotated, therefore, for a binary image, if we rotate it by 90°, 180° and 270° clockwise, the bitquad patterns Q _{2} and Q _{ c } needed to be counted will become to the patterns shown in Fig. 12b–d, respectively. Theoretically, we can use any of the groups of the patterns to compute the Euler number of a binary image.
Time complexity
According to the analysis results given in related references, for calculating the Euler number of an M × Nsize binary image, the skeletonbased algorithm will take about 8 M × N pixel accesses (DiazdeLeon and SossaAzuela 1996), the GRAY algorithm will take 4 M × N pixel accesses, the RUN algorithm will take about 4 M × N pixel accesses in the worst case, and about 3 M × N pixel accesses in average (Bishnu et al. 2005). Moreover, the HCS algorithm will take 2.375 M × N pixel accesses in average (He et al. 2013). Taking advantage of the information obtained during processing the previous bitquad, the IGRAY algorithm will only take 2 M × N pixel accesses (Yao et al. 2014). Therefore, the IGRAY algorithm is better than the skeletonbased algorithm, the GRAY algorithm, the RUN algorithm, and the HCS algorithm.
In our algorithm, as introduced in “Our proposed algorithm”, for processing a bitquad \(\left[ {\begin{array}{*{20}c} U & X \\ V & Y \\ \end{array} } \right]\), the pixels in the bitquad will be checked in the order U → V → X → Y. If U is an object pixel, i.e., the bitquad is \(\left[ {\begin{array}{*{20}c} 1 & X \\ V & Y \\ \end{array} } \right]\) (the patterns Q _{9}–Q _{16} in Table 3), denoted as R1, we will do nothing else. Thus, we only need to check one pixel. Otherwise, if U is a background pixel, we will check V and X. For a bitquad such as \(\left[ {\begin{array}{*{20}c} 0 & 1 \\ 0 & Y \\ \end{array} } \right]\) or \(\left[ {\begin{array}{*{20}c} 0 & 1 \\ 1 & Y \\ \end{array} } \right]\) (the patterns Q _{5}–Q _{8} in Table 3), denoted as R2, we need to check three pixels, but we can skip over the next bitquad, thus, we need to check 1.5 pixels for processing a bitquad in average. For each of the rest patterns such as \(\left[ {\begin{array}{*{20}c} 0 & 0 \\ 1 & 0 \\ \end{array} } \right]\), \(\left[ {\begin{array}{*{20}c} 0 & 0 \\ 1 & 1 \\ \end{array} } \right]\), \(\left[ {\begin{array}{*{20}c} 0 & 0 \\ 0 & 1 \\ \end{array} } \right]\) or \(\left[ {\begin{array}{*{20}c} 0 & 0 \\ 0 & 0 \\ \end{array} } \right]\) (the patterns Q _{1}–Q _{4} in Table 3), denoted as R3, we need to check two pixels for processing the bitquad if it follows another such a pattern of R3. Otherwise, all the four pixels in the bitquad will be checked. Suppose that all patterns of bitquads occur in same probability, then, the probability that a pattern of R3 follows another pattern of R3 is 4/16 = 1/4. Thus, the average number of pixels to be checked for processing a bitquad of pattern R3 will be 2 × 4/16 + 4 × 12/16 = 3.5.
According to above analysis, by our algorithm,the average number of pixels to be checked for processing a bitquad will be (1 × 8 + 1.5 × 4 + 3.5 × 4)/16 = 1.75. Thus, for an M × Nsize binary image, our algorithm will take about 1.75 M × N pixel accesses, which is less than the number of pixel accesses in any of conventional Euler number computing algorithms. Therefore, our algorithm will be more efficient than any of conventional algorithms.
The above analysis results are consistent with our experimental results. As mentioned in “Experimental results”, except one image, our algorithm is more efficient than all conventional Euler number computing algorithm in comparison for all images used in our test.
Conclusion
In this paper, we presented a novel bitquadbased algorithm for Euler number computing. According to graph theory and analysis on bitquad patterns, we only need to count two bitquad patterns, much less than ten patterns counted in conventional bitquadbased algorithms. Together with use of the information obtained during processing the previous bitquad, our algorithm checks only 1.75 pixels for processing a bitquad in average. Experimental results on various types of images demonstrated that our algorithm outperformed conventional Euler number computing algorithms. For future work, we will consider hardware implementation and parallel implementation of our algorithm.
Notes
 1.
Because pixels in the image are processed in the raster scan, all pixels in the bitquad except the representative pixels have been processed before processing the representative pixel.
 2.
The images can be downloaded at http://sampl.ece.ohiostate.edu/data/stills/sidba/index.htm.
 3.
The images can be downloaded at http://sipi.usc.edu/database/.
 4.
The images can be downloaded at http://www1.cs.columbia.edu/CAVE/software/curet/.
 5.
The density of foreground pixels in a binary image refers to the proportion of foreground pixels in the image. Thus, if all pixels in a binary image are background pixels, the density of the image will be 0. On the other hand, if all the pixels are foreground pixels, the density will be 1.
References
Azuela Sossa et al (2014) Alternative formulations to compute the binary shape Euler number. IET Comput Vision 8(3):171–181
Bishnu A et al (2005) A pipeline architecture for computing the Euler number of a binary image. J Syst Architect 51(8):470–487
Chen MH, Yan PF (1988) A fast algorithm to calculate the Euler number for binary images. Pattern Recognit Lett 8(5):295–297
Chiavetta F, Gesu V (1993) Parallel computation of the Euler number via connectivity graph. Pattern Recognit Lett 14:849–859
DiazdeLeon SJL, SossaAzuela JH (1996) On the computation of the Euler number of a binary object. Pattern Recogn 29(3):471–476
Dey S et al (2000) A fast algorithm for computing the Euler number of an image and its VLSI implementation. In VLSI Design, Thirteenth International Conference on IEEE, pp 330–335
Dyer CR (1980) Computing the Euler number of an image from its quadtree. Comput Graph Image Process 13(3):270–276
Gonzalez RC, Woods RE (2008) Digital Image Processing, 3rd edn. Pearson PrenticeHall, Upper Saddle River, NJ
Gray SB (1971) Local properties of binary images in two dimensions. IEEE Trans Comput C20:551–561
Hashizume A et al (1990) An algorithm of automated RBC classification and its evaluation. Bio Med Eng 28(1):25–32
He L, Chao Y (2015) A Very Fast Algorithm for Simultaneously Performing ConnectedComponent Labeling and Euler Number Computing. IEEE Trans Image Process 24(9):2725–2735
He L et al (2010) An efficient firstscan method for labelequivalencebased labeling algorithms. Pattern Recogn Lett 31(1):28–35
He L et al (2013) An algorithm for connectedcomponent labeling, hole labeling and Euler number computing. J Comput Sci Technol 28(3):469–479
Horn B (1986) Robot Vision. McGrawHill, New York, pp 73–77
Karnaugh M (1953) The map method for synthesis of combinational logic circuits. Trans AIEE pt I 72(9):593–599
Nayar SK, Bolle RM (1996) Reflectancebased object recognition. Int J Comput Vision 17(3):219–240
Pogue BW et al (2000) Image analysis for discrimination of cervical neoplasia. J Biomed Optics 5(1):72–82
Rosin PL, Ellis T (1995) Image difference Threshold strategies and shadow detection. Proceedings of the British Machine Vision Conference September, pp 347–356
Samet H, Tamminen H (1985) Computing geometric properties of images represented by linear quadtrees. IEEE Trans PAMI 7(2):229–240
SossaAzuelal et al (2013) Computing the Euler number of a binary image based on a vertex codification. J Appl Res Technol 11:360–370
Srihari SN (1986) Document image understanding. In Proc. ACM/IEEE Joint Fall Computer Conference, Dallas, TX, pp 87–95
Thompson CM, Shure L (1995) Image Processing Toolbox: For Use with Matlab. The Math Works Inc, Natick, Massachusetts
West DB (2001) Introduction to Graph Theory, 2nd edn. Pearson PrenticeHall, Uper Saddle River, NJ
Yao B et al (2014) An efficient strategy for bitquadbased Euler number computing algorithm. IEICE TRANS Inf Syst E97(D5):1374–1378
Yao B et al (2015) A new runbased algorithm for Euler number computing. Pattern Anal Appl. doi:10.1007/s1004401504644 (In press)
Authors’ contributions
BY and LH propose and implement the algorithm for computing Euler number and drafted the manuscript. SK and YC carried out the experiment and helped to draft the manuscript. XZ performed the statistical analysis. All authors read and approved the final manuscript.
Acknowledgements
This work was supported in part by the GrantinAid for the National Natural Science Foundation of China under Grant No. 61471227, the Scientific Research (C) of the Ministry of Education, Science, Sports and Culture of Japan under Grant No. 26330200, and the GrantinAid for Scientific Research of Shaanxi Province of China under Grant No. 2014K11020113.
Competing interests
The authors declare that they have no competing interests.
Author information
Rights and permissions
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.
About this article
Received
Accepted
Published
DOI
Keywords
 Euler number
 Graph theory
 Computer vision
 Pattern recognition
 Topological property